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;
}