《大话设计模式》c++实现 之策略模式

一、UML图

 

二、概念

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

 

三、优点

（1）策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，他可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

（2）策略模式的Strategy类曾是为Context定义了一些列的可供重用的算法或行为。集成有助于析取出这些算法中的公共功能。

（3）策略模式简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。

（4）策略模式就是用来封装算法的。

（5）只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。

（6）简单工厂模式需要让客户端认识两个类，而策略模式和简单工厂模式结合的用法，客户端只需要认识一个类Context即可。

四 与工厂模式的区别：

工厂模式用来选择分支，产生不同的产品，（类）

策略模式是针对算法的，不同的算法用不同的类

 #include <iostream>
 using namespace std;

 // 抽象产品类
 class Operation{
 protected:
     double num1;
     double num2;
 public:
     double get_n1(){
         return num1;
     }
     double get_n2(){
         return num2;
     }
     void set_n1(int num){
         num1 = num;
     }
     void set_n2(int num){
         num2 = num;
     }
     virtual double GetResult(){
         double result = ;
         return result;
     }

 };
 //具体产品类
 class OperationAdd :public Operation{
 public:
     double GetResult(){
         double result = ;
         result = num1 + num2;
         return result;
     }
 };

 //具体产品类
 class OperationSub :public Operation{
 public:
     double GetResult(){
         double result = ;
         result = num1 - num2;
         return result;
     }
 };

 //具体产品类
 class OperationMul :public Operation{
 public:
     double GetResult(){
         double result = ;
         result = num1 * num2;
         return result;
     }
 };

 //具体产品类
 class OperationDiv :public Operation{
 public:
     double GetResult(){
         double result = ;
         if (num2 != )
             result = num1 / num2;
         return result;
     }
 };
 //工厂类

 class OperationFactory{
 public:
     Operation* createOperation(char type){
         Operation* oper = NULL;
         switch (type)
         {
         case '+':
             oper = new OperationAdd;
             break;
         case '-':
             oper = new OperationSub;
             break;
         case '*':
             oper = new OperationMul;
             break;
         case '/':
             oper = new OperationDiv;
             break;
         }
         return oper;
     }
 };

 //策略类
 class Context{
 private:
     Operation* op_;
 public:
     Context(char type){
         OperationFactory of;
         op_ = of.createOperation(type);
     }
     double executeOperation(double num1, double num2){
         op_->set_n1(num1);
         op_->set_n2(num2);
         return op_->GetResult();
     }

 };

 void main(){

     double res = ;
     Context co = Context('+');
     res = co.executeOperation(, );
     cout << res << endl;

     Context co2 = Context('-');
     res = co2.executeOperation(, );
     cout << res << endl;

     system("pause");
 }

参考：

http://www.runoob.com/design-pattern/strategy-pattern.html

https://blog.csdn.net/xiqingnian/article/details/41855391