策略模式是一种行为型设计模式。它定义一系列的算法，将它们封装起来，并允许它们相互替换。这种设计模式使得算法可独立于使用它的客户而变化，从而实现代码的灵活性和可扩展性。

策略模式结构图

#include <iostream>
#include <list>
#include <memory>
#include <string>

class Strategy {
public:
    using Ptr = std::shared_ptr<Strategy>;
    Strategy() {}
    virtual ~Strategy() {}
    virtual void AlgorithmInterface() = 0;
};

class Context {
public:
    Context(Strategy* strategy) : _strategy(strategy) {}
    virtual ~Context() {}
    void ContextInterface() {
        if (_strategy) {
            _strategy->AlgorithmInterface();
        }
    }
    void ChangeStrategy(Strategy* strategy) {
        _strategy = strategy;
    }
protected:
    Strategy* _strategy;
};

class ConcreteStrategyA : public Strategy {
public:
    ConcreteStrategyA() {}
    virtual ~ConcreteStrategyA() {}
    void AlgorithmInterface() override {
        std::cout << "Strategy A" << std::endl;
    }
};

class ConcreteStrategyB : public Strategy {
public:
    ConcreteStrategyB() {}
    virtual ~ConcreteStrategyB() {}
    void AlgorithmInterface() override {
        std::cout << "Strategy B" << std::endl;
    }
};

int main(int argc, char* argv[]) {
    Strategy::Ptr strategyA = std::make_shared<ConcreteStrategyA>();
    Context ctx(strategyA.get());
    ctx.ContextInterface();

    Strategy::Ptr strategyB = std::make_shared<ConcreteStrategyB>();
    // 改变策略
    ctx.ChangeStrategy(strategyB.get());
    ctx.ContextInterface();

    return 0;
}

策略模式运行结果

1. 当许多相关的类仅仅是行为有差异时，可以使用“策略”来配置一个类。
2. 当需要使用一个算法的不同变体时，可以使用策略模式。例如，可能会定义一些反映不同的空间/时间权衡的算法。当这些变体实现为一个算法的类层次时，可以使用策略模式。
3. 当一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现时，可以使用策略模式。将相关的条件分支移入它们各自的策略类中以代替这些条件语句，可以提高代码的可读性和可维护性。