大话设计模式学习（二）——策略模式

策略模式：定义了算法家族，分别封装起来，让它们之间可以互相替换， 此模式让算法的变化， 不会影响到使用算法的客户

//策略基类 class Strategy { public: //定义算法接口 virtual void AlgorithmInterface(); }; class ConcreteStrategyA : public Strategy { public: void AlgorithmInterface() { CString strOutput=_T("算法A实现"); cout<<strOutput<<endl; } } ; class ConcreteStrategyB : public Strategy { public: void AlgorithmInterface() { CString strOutput=_T("算法B实现"); cout<<strOutput<<endl; } } ; class ConcreteStrategyC : public Strategy { public: void AlgorithmInterface() { CString strOutput=_T("算法C实现"); cout<<strOutput<<endl; } } ;

接下来定义Context类

class Context { public: Context(Strategy* pStrategy) { strategy=pStrategy; } void ContextInterface() { strategy->AlgorithmInterface(); } private: Strategy *strategy; };

客户端程序

#include <iostream> using namespace std; void main(int argc,char*argv[]) { CString strInput; char putIn=*argv[1]; Context* pContext; switch(putIn) { case 'A': pContext=new Context(new ConcreteStrategyA()); break; case 'B': pContext=new Context(new ConcreteStrategyB()); break; case 'C': pContext=new Context(new ConcreteStrategyC()); break; } pContext->ContextInterface(); }

注意到这里也是在客户端判断用哪个算法，我们可以将简单工厂和策略结合，将这个判断集成到Context类的构造函数中

Context(char cInputType) { switch(cInputType) { case 'A': strategy=new ConcreteStrategyA(); break; case 'B': strategy=new ConcreteStrategyB(); break; case 'C': strategy=new ConcreteStrategyC(); break; } }

这样，客户端代码变为

#include <iostream> using namespace std; void main(int argc,char*argv[]) { CString strInput; char putIn=*argv[1]; Context* pContext=new Context(putIn); pContext->ContextInterface(); }

和前面简单工厂类的客户端代码对比一下

简单工厂模式的用法：

MyOperation* oper=OperationFactory::creatOperation(putIn);

策略模式与简单工厂结合的用法：

Context* pContext=new Context(putIn);

简单工厂模式需要让用户认识两个类：MyOperation和OperationFactory,而策略模式和简单模式相结合的方式，只需要认识Context一个类。

策略模式是有缺点的，客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类。换言之，策略模式只适用于客户端知道所有的算法或行为的情况。