设计模式之Strategy模式(策略模式)

在介绍策略模式之前，我们先来看看多态性。多态性很好理解，策略模式就是在多态性的基础上进行修改。

1.首先定义个父类，定义了所有的函数接口，但不去实现它。

假设父类名为CStrategy，这里设计为抽象类

#pragma once
class CStrategy
{
public:
	CStrategy(void);
	virtual ~CStrategy(void);
	virtual void Operation()=0;
};

#include "Strategy.h"

CStrategy::CStrategy(void)
{
}

CStrategy::~CStrategy(void)
{
}

在定义2个子类，具体实现的过程在里面

#pragma once
#include "strategy.h"
#include <stdio.h>
class CStrategyOne :
	public CStrategy
{
public:
	CStrategyOne(void);
	virtual ~CStrategyOne(void);
	virtual void Operation();
};

#include "StrategyOne.h"

CStrategyOne::CStrategyOne(void)
{
}

CStrategyOne::~CStrategyOne(void)
{
}

void CStrategyOne::Operation()
{
	printf("StrategyOne Operation\n");//具体实现
}

#pragma once
#include "strategy.h"
#include <stdio.h>
class CStrategyTwo :
	public CStrategy
{
public:
	CStrategyTwo(void);
	virtual ~CStrategyTwo(void);
	virtual void Operation();
};

#include "StrategyTwo.h"

CStrategyTwo::CStrategyTwo(void)
{
}


CStrategyTwo::~CStrategyTwo(void)
{
}

void CStrategyTwo::Operation()
{
	printf("StrategyTwo Operation\n");//具体实现
}

实际调用过程

	CStrategy *p1=new CStrategyOne();
	p1->Operation();
	CStrategy *p2=new CStrategyTwo();
	p2->Operation();

这就是一个多态的实际调用，很简单，策略模式就是对多态封装一个类就行了，然后传入不同的参数即可

2.定义一个环境类，在环境类里面传入一个对象，策略类里面封装同样的方法。

#pragma once
#include "Strategy.h"
class CContext
{
public:
	CContext(CStrategy *pStrategy);
	virtual ~CContext(void);
	virtual void Operation(); //封装同样的方法
private:
	CStrategy *m_pStratey;
};

CContext::CContext(CStrategy *pStrategy):m_pStratey(pStrategy) //传入策略对象
{
}

CContext::~CContext(void)
{
}

void CContext::Operation()
{
	m_pStratey->Operation(); //更具参数进行不同的操作
}

3.实际调用

        CContext *p1=new CContext(new CStrategyOne); //传入不同的对象
	p1->Operation();                             //具体操作
	CContext *p2=new CContext(new CStrategyTwo);
	p2->Operation();