策略模式（Strategy Pattern）

策略模式（Strategy Pattern） —— 定义一系列的算法，把它们一个个封装起来，而且使它们可互相替换。本模式使得算法的变化可独立于使用它的客户。

在存在如下状况时可以使用Strategy模式：

• 须要使用一个算法的不一样变体。（例如对称加密算法，可以使用AES、RSA、DES等）

• 一个类定义了多种行为，而且这些行为在这个类的操做中以多个条件语句的形式出现。可将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。（缺点是增长了对象的数目）

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

#include<iostream>
using namespace std;

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

// 策略A
class ConcreteStrategyA :public Strategy{
public:
    ConcreteStrategyA(){}
    ~ConcreteStrategyA(){}
    void AlgrithmInterface(){
        cout<<"A strategy impl."<<endl;
    }
};

// 策略B
class ConcreteStrategyB :public Strategy {
public:
    ConcreteStrategyB(){}
    ~ConcreteStrategyB(){}
    void AlgrithmInterface(){
        cout<<"B strategy impl."<<endl;
    }
};

class Context {
public:
    Context(Strategy* s){
        m_strategy = s;
    }
    ~Context(){}
    void DoAction(){
    cout<<"Context DoAction:"<<endl;
        m_strategy->AlgrithmInterface();
    }
    void change_strategy(Strategy* v){
        m_strategy = v;
    }
private:
    Strategy* m_strategy;
};


int main(){
    Strategy* sa = new ConcreteStrategyA();
    Context* con = new Context(sa);
    con->DoAction();

    Strategy* sb = new ConcreteStrategyB();
    con->change_strategy(sb);
    con->DoAction();

    delete sa;
    delete sb;
    delete con;

    return 0
}
复制代码

能够看到策略模式很是简单直接，其实就是将策略进行抽象，对不一样的策略子类实现具体的方法，使用策略时，选择对应策略的子类对象便可。