策略模式 – 算法替换，灵活变化

策略模式（Strategy Pattern）是一种行为设计模式，它定义了一系列算法，并将每一个算法封装起来，使它们可以互相替换。策略模式让算法的变化独立于使用算法的客户。这种模式主要涉及到三个角色：

组成

1. 上下文（Context）：持有一个策略类的引用，最终给客户端调用。
2. 抽象策略类（Strategy）：定义所有支持的算法的公共接口。Context使用这个接口来调用某个ConcreteStrategy定义的算法。
3. 具体策略类（ConcreteStrategy）：实现抽象策略中的操作，即具体的算法实现。

策略模式的优点

1. 策略模式之间可以自由的切换：由于策略类都实现同一个接口，所以一种策略的切换很容易；
2. 易于扩展：增加一个新的策略只需要实现接口即可，符合开闭原则；
3. 避免使用多重条件判断：如果不使用策略模式，很多时候需要通过if-else来决定使用哪种算法，策略模式可以避免这种情况。

缺点

1. 客户端必须知道所有的策略类：这是因为客户端需要决定使用哪一个策略类。
2. 产生很多策略类：每一个策略都是一个类，随着策略的增加，类的数量也会增加。

使用场景

1. 当你想使用对象中的算法变化的时候，可以使用策略模式。而且，你可以独立于客户端使用不同的算法。
2. 当你有很多类仅在它们的行为上稍有不同的场景。策略模式提供了一种配置类中具有不同行为的方法。

实现

1. 实现抽象策略类

class Strategy {
public:
    virtual ~Strategy() {}
    virtual void AlgorithmInterface() = 0;
};

2. 具体策略类A

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

3. 具体策略类B

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

4. 上下文

class Context {
private:
    Strategy* strategy;
public:
    Context(Strategy* strategy) : strategy(strategy) {}
    ~Context() {
        delete strategy;
    }
    void ContextInterface() {
        strategy->AlgorithmInterface();
    }
};

5. 测试

int main() {
    Strategy* strategyA = new ConcreteStrategyA();
    Context* context = new Context(strategyA);
    context->ContextInterface();

    delete context; // 注意适时释放资源

    Strategy* strategyB = new ConcreteStrategyB();
    context = new Context(strategyB);
    context->ContextInterface();

    delete context; // 注意适时释放资源

    return 0;
}

6. 输出

Implementing Algorithm A
Implementing Algorithm B