设计模式21之c++策略模式(含示例代码)

策略模式是一种行为型设计模式，它定义了一系列的算法，并将每个算法封装起来，使它们可以相互替换。

下面是一个使用 C++ 实现策略模式的示例代码：

#include <iostream>
#include <vector>
// 抽象策略类：定义了所有具体策略类的接口
class Strategy {
    
    
public:
    virtual ~Strategy() {
    
    }
    virtual void ExecuteStrategy() = 0;
};
// 具体策略类：实现了抽象策略类的接口
class ConcreteStrategyA : public Strategy {
    
    
public:
    virtual ~ConcreteStrategyA() {
    
    }
    virtual void ExecuteStrategy() override {
    
    
        std::cout << "Concrete Strategy A" << std::endl;
    }
};
class ConcreteStrategyB : public Strategy {
    
    
public:
    virtual ~ConcreteStrategyB() {
    
    }
    virtual void ExecuteStrategy() override {
    
    
        std::cout << "Concrete Strategy B" << std::endl;
    }
};
// 上下文类：维护一个具体策略类的实例，并定义了一个接口供外部调用
class Context {
    
    
public:
    Context(Strategy* strategy) : strategy_(strategy) {
    
    }
    ~Context() {
    
    
        delete strategy_;
    }
    void Execute() {
    
    
        strategy_->ExecuteStrategy();
    }
    void ChangeStrategy(Strategy* strategy) {
    
    
        delete strategy_;
        strategy_ = strategy;
    }
private:
    Strategy* strategy_;
};
int main() {
    
    
    // 创建具体策略对象
    ConcreteStrategyA* strategy_a = new ConcreteStrategyA();
    ConcreteStrategyB* strategy_b = new ConcreteStrategyB();
    // 创建上下文对象，并设置初始策略为 ConcreteStrategyA
    Context context(strategy_a);
    // 调用上下文对象的接口，输出 "Concrete Strategy A"
    context.Execute();
    // 改变上下文对象的策略为 ConcreteStrategyB
    context.ChangeStrategy(strategy_b);
    // 再次调用上下文对象的接口，输出 "Concrete Strategy B"
    context.Execute();
    return 0;
}

在上面的代码中，我们首先定义了一个抽象策略类 Strategy，它定义了所有具体策略类的接口。接着，我们创建了两个具体策略类 ConcreteStrategyA 和 ConcreteStrategyB，它们实现了抽象策略类的接口。最后，我们定义了一个上下文类 Context，它维护了一个具体策略类的实例，并定义了一个接口供外部调用。

在 main() 函数中，我们创建了两个具体策略对象 strategy_a 和 strategy_b，并将 strategy_a 作为初始策略，然后创建了一个上下文对象 context，并调用它的接口 Execute() 输出 “Concrete Strategy A”。接着，我们将上下文对象的策略改变为 strategy_b，再次调用 Execute() 接口，输出 “Concrete Strategy B”。

策略模式的优点在于它将算法的实现与使用分离开来，并使得每个算法都可以独立地变化。同时，策略模式也使得我们可以简化条件语句的复杂度，使得代码更加清晰易懂。但是，策略模式可能会导致类的数量增加，从而增加了代码的复杂度。