Strategy模式

class AbstractStrategy
{
public:
	virtual void Algorithm(int data)=0;
	virtual ~AbstractStrategy() {}
};

class ConcreteStrategy1 : public AbstractStrategy
{
public:
	void Algorithm(int data)
	{
		cout<<data*10<<endl;
		cout<<"ConcreteStrategy1::Algorithm(int data)"<<endl;
	}
};

class ConcreteStrategy2:public AbstractStrategy
{
public:
	void Algorithm(int data)
	{
		cout<<data*100<<endl;
		cout<<"ConcreteStrategy2::Algorithm(int data)"<<endl;
	}
};

class Context
{
public:
	Context(int data,AbstractStrategy* p):data(data),pStrategy(p) {}

	void changeStratege(AbstractStrategy* p)
	{
		pStrategy=p;
	}

	void doSomething()
	{
		pStrategy->Algorithm(data);
	}
private:
	AbstractStrategy *pStrategy;
	int data;
};

int _tmain(int argc, _TCHAR* argv[])
{
	AbstractStrategy *p=new ConcreteStrategy1();
	Context c(10,p);
	c.doSomething();
	delete p;

	p=new ConcreteStrategy2();
	c.changeStratege(p);
	c.doSomething();
	delete p;

	return 0;
}

意图：把一系列的算法封装起来，并且使他们可以相互替换。使算法可以独立于它的客户而变化。

结构图如下：

在Context中添加了一个changeStrategy的函数，可以在处理过程中随时改变处理数据的算法。

这里我只是写了一个小例子，在实际的应用中，往往策略类需要一个上下文类的引用，以便通过上下文类的public接口来获得一些计算所需要的数据。

在上下文类，需要一个策略类的指针，以便维护这个策略指针，方便知道当前采取的什么策略。

因此需要在策略类和上下文类的头文件中声明彼此，不需要包含头文件。

在实现文件包含头文件即可。