设计模式——策划模式（C++）——算法实现

意图： 定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换

主要解决： 在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。

何时使用： 一个系统有许多许多类，而区分它们的只是他们直接的行为。

如何解决： 将这些算法封装成一个一个的类，任意地替换。

关键代码： 实现同一个接口。

优点：

1、算法可以自由切换。
2、避免使用多重条件判断。
3、扩展性良好。

缺点：

1、策略类会增多。
2、所有策略类都需要对外暴露。

使用场景：

1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。
2、一个系统需要动态地在几种算法中选择一种。
3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

#include <iostream>
using namespace std;

//抽象算法类：定义所有支持的算法的公共接口
class Strategy
{
    public:
        virtual void AlgorithmInterface()=0;
};


//具体算法A：封装了具体的算法或行为，继承于抽象算法类
class ConcreteStrategyA : public Strategy
{
    public:
        virtual void AlgorithmInterface()
        {
            cout<<"算法A实现"<<endl;
        }
};

//具体算法B：封装了具体的算法或行为，继承于抽象算法类
class ConcreteStrategyB:public Strategy
{
    public:
        virtual void AlgorithmInterface()
        {
            cout<<"算法B实现"<<endl;
        }
};

//具体算法C：封装了具体的算法或行为，继承于抽象算法类
class ConcreteStrategyC:public Strategy
{
    public:
        virtual void AlgorithmInterface()
        {
            cout<<"算法C实现"<<endl;
        }
};


//在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。
//Context 类:维护一个对抽象算法类对象的引用
class Context
{
    private:
        Strategy* strategy;
    public:
        void SetContext(Strategy* s)
        {
            this->strategy = s;
        }
        void ContextInterface()
        {
            strategy->AlgorithmInterface();
        }
};


//由于实例化不同的策略，最终在调用context->ContextInterface()时，所获得的结果就不尽相同。
int main()
{
    ConcreteStrategyA* strategyA = new ConcreteStrategyA;
    ConcreteStrategyB* strategyB = new ConcreteStrategyB;
    ConcreteStrategyC* strategyC = new ConcreteStrategyC;
    Context* context = new Context;
    context->SetContext(strategyA);
    context->ContextInterface();
    context->SetContext(strategyB);
    context->ContextInterface();
    context->SetContext(strategyC);
    context->ContextInterface();
    system("pause"); 
    return 0;
}

学习来源：《大话模式设计》、《菜鸟教程》