C++行为型模式-策略模式用法总结

1 模式概念

策略模式（Strategy Pattern）,定义一系列算法，将每一个算法封装起来，并让它们可以相互替换，策略模式是一种对象 行为型模式。

符合依赖倒置原则：

依赖倒置原则

A.高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。

B.抽象不应该依赖于具体，具体应该依赖于抽象。

2 模式结构

（1） Context  环境类

环境类是使用算法的角色，它在解决某个问题时可以采用多种策略

（2）Strategy 抽象策略类

抽象策略类为所支持的算法声明了抽象方法，是所有策略类的父类，可以是抽象类，也可以是接口。

（3）ConcreteStrategy 具体策略类

具体策略类实现了在抽象类中定义的算法，在运行时，具体策略类将覆盖在环境类中定义的抽象策略类，使用一种具体的算法实现某个业务处理。

3 模式优缺点

1. 优点

• 符合“开闭原则”，用户可以在不修改原有系统的基础上选择算法和行为，也可以灵活的增加新的算法和行为。
• 策略模式提供了管理相关算法族的办法。可以把公共的代码移植到父类中，从而避免重复的代码。
• 符合“单一职责原则”；
• 避免多重条件转换语句。

2. 缺点

• 客户端必须知道所有的策略类，并自行决定使用哪个策略类；
• 策略模式将产生很多策略类和对象，可以通过使用享元模式减少对象的数量。

4 应用场景

• 系统中有许多类，它们之间的区别仅在于它们的行为，使用策略模式可以动态地让一个对象在许多行为中选择一种行为。

策略者模式与简单工厂模式的区别：

 （1）简单工厂模式是创建型模式， 简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建并且返回哪一个产品类（这些产品类继承自一个父类或接口）的实例。在创建对象上的灵活性高，但是工厂类只能创建可能会使用到的产品类，假如新添了产品类就得修改工厂类，这样就会违反开闭原则。

（2）策略模式是行为型模式，它定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

（3）在运行时，两者都是通过传入参数进行配置，简单工厂模式则是选择创建出需要的对象，而策略模式则是配置出需要的行为算法。一个是对象创建，另一个是行为算法的替换。

5 应用举例

#include
using namespace std;
//抽象策略类
class Strategy{
public :
    virtual void AlgorithmInterface() = 0;
};
//具体策略类  StrategyA
class StrategyA : public Strategy{
public :
    void AlgorithmInterface(){
        //算法A
        cout << "this is StrategyA" << endl;
    }
};
//具体策略类  StrategyB
class StrategyB : public Strategy{
public :
    void AlgorithmInterface(){
        //算法B
        cout << "this is StrategyB" << endl;
    }
};

//环境类
class Context{
public:
    Context(Strategy *pStrategy ):pStrategy(pStrategy){}//初始化是传入具体的策略对象
    void ContextInterface(){
        pStrategy->AlgorithmInterface();//根据具体的策略对象，调用其算法方法
    }
private :
    Strategy *pStrategy;
};

int main(){
    Strategy *pstrategyA = new StrategyA();
    Strategy *pstrategyB = new StrategyB();
  
    Context *pcontextA = new Context(pstrategyA);
    Context *pcontextB = new Context(pstrategyB);
   
    pcontextA->ContextInterface();
    pcontextB->ContextInterface();
   
    if(pstrategyA)delete pstrategyA;
    if(pstrategyB)delete pstrategyB;
   
    if(pcontextA)delete pcontextA;
    if(pcontextB)delete pcontextB;
   
    return 0;
}

输出：

 this is StrategyA
 this is StrategyB

6 策略与简单工厂结合

我们知道已有的AB两种算法，但是我们又不确定运行时使用哪种算法，同时为了让客户端和业务逻辑代码隔离开，于是，我们可以将客户端的创建算法类的业务逻辑转移到Cotent类，并添加一个创建算法工厂的方法。

#include
using namespace std;
typedef enum StrategyTypeTag
{
  strategyA,
  strategyB,
}StrategyType;

//抽象策略类
class Strategy{
public :
    virtual void AlgorithmInterface() = 0;
};

//具体策略类  StrategyA
class StrategyA : public Strategy{
public :
    void AlgorithmInterface(){
        //算法A
        cout << "算法A实现" << endl;
    }
};
//具体策略类  StrategyB
class StrategyB : public Strategy{
public :
    void AlgorithmInterface(){
        //算法B
        cout << "算法B实现" << endl;
    }
};

//环境类
class Context{
public:
    Context(Strategy *pStrategy ):pStrategy(pStrategy){}//初始化是传入具体的策略对象
    void ContextInterface(){
        pStrategy->AlgorithmInterface();//根据具体的策略对象，调用其算法方法
    }
private :
    Strategy *pStrategy;
};

// 工厂类
class Factory
{
public:
  Strategy* CreateStrategy(StrategyType type)
  {
    switch (type)
    {
    case strategyA:
      return new StrategyA();
    case strategyB:
      return new StrategyB();
    default:
      return NULL;
    }
}
};

int main(){
  
Factory *pFactory = new Factory();
    Strategy *pstrategy = pFactory -> CreateStrategy(strategyA);
	
    Context *pcontext = new Context(pstrategy);
  
    pcontext->ContextInterface();
    if(pFactory)delete pFactory;
    if(pstrategy)delete pstrategy;
    if(pcontext)delete pcontext;
   
    return 0;
}

参考文献：

【1】C++：策略模式： C++：策略模式_xizi_ghq的博客-CSDN博客_c++策略模式

【2】简单工厂模式和策略模式的区别与结合 - 陈珙 - 博客园

【3】策略模式和简单工厂模式的结合使用 - 以前、以后 - 博客园