c++策略模式strategy

意图：

       定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

适用性：

      许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法。

      需要使用一个算法的不同变体。例如，你可能会定义一些反映不同的空间/时间权衡的算法。

      算法使用客户不应该知道的数据。可使用策略模式以避免暴露复杂的、与算法相关的数据结构。

      一个类定义了多种行为, 并且这些行为在这个类的操作中以多个条件语句的形式出现。将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Strategy
{
public:
	virtual void AlgorithomInterface() {};
};

class ConcreteStrategy1 :public Strategy
{
	void AlgorithomInterface()
	{
		cout << "I am  AlgorithomInterface 1" << endl;
	}
};

class ConcreteStrategy2 :public Strategy
{
	void AlgorithomInterface()
	{
		cout << "I am  AlgorithomInterface 2" << endl;
	}
};

class ConcreteStrategy3 :public Strategy
{
	void AlgorithomInterface()
	{
		cout << "I am  AlgorithomInterface 3" << endl;
	}
};

class Context
{
public:
	Context(){}
	Context(Strategy *strategy) :m_strategy(strategy){}
	~Context(){ delete m_strategy; }

	void ContextInterface()
	{
		m_strategy->AlgorithomInterface();
	}

private:
	Strategy *m_strategy;
};

int main()
{
	Context *pContextA = new Context(new ConcreteStrategy1());
	Context *pContextB = new Context(new ConcreteStrategy2());

	pContextA->ContextInterface();
	pContextB->ContextInterface();

	delete pContextA;
	delete pContextB;

	return 0;
}

二我们可以结合简单工厂模式来定义，因为在实际操作的过程中，我们会发现，在main函数中，也就是在客户端使用策略模式时，会创建非常多的Strategy，而这样就莫名的增加了客户端的压力，让客户端的复杂度陡然增加了。那么，我们就可以借鉴简单工厂模式，使策略模式 和简单工厂相结合，从而减轻客户端的压力，代码实现如下：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

typedef enum StrategyType
{
	strategy1,
	strategy2,
	strategy3,
}STRATEGYTYPE;

class Strategy
{
public:
	virtual void AlgorithomInterface() {};
};

class ConcreteStrategy1 :public Strategy
{
	void AlgorithomInterface()
	{
		cout << "I am  AlgorithomInterface 1" << endl;
	}
};

class ConcreteStrategy2 :public Strategy
{
	void AlgorithomInterface()
	{
		cout << "I am  AlgorithomInterface 2" << endl;
	}
};

class ConcreteStrategy3 :public Strategy
{
	void AlgorithomInterface()
	{
		cout << "I am  AlgorithomInterface 3" << endl;
	}
};

class Context
{
public:
	Context(){}
	Context(STRATEGYTYPE type)
	{
		switch (type)
		{
		case strategy1:
			m_strategy = new ConcreteStrategy1;
			break;

		case strategy2:
			m_strategy = new ConcreteStrategy2;
				break;

		case strategy3:
			m_strategy = new ConcreteStrategy3;
				break;
		default:
			break;
		}
	}

	~Context(){ delete m_strategy; }

	void ContextInterface()
	{
		m_strategy->AlgorithomInterface();
	}

private:
	Strategy *m_strategy;
};

int main()
{
	Context *pContextA = new Context(strategy3);
	pContextA->ContextInterface();
	delete pContextA;

	return 0;
}