设计模式--策略模式（Strategy Pattern）

策略模式（Strategy Pattern）是一种行为设计模式，它定义了一系列的算法，并将每一个算法封装起来，使它们可以互相替换，让算法独立于使用它的客户端。

策略模式主要包含以下几个角色：

Strategy（策略）：这是一个接口，通常用于定义所有支持的算法的公共接口。
ConcreteStrategy（具体策略）：这是实现了Strategy接口的具体算法类。每一个ConcreteStrategy都包装了一种具体的算法或行为。
Context（上下文）：这是一个使用策略对象的类。通常它包含一个策略对象，并且可以定义一个接口来让策略访问它的数据。

策略模式的主要优点是：

定义了一系列可重用的策略或算法，并让客户端可以选择其中一个策略或算法，也可以动态地切换策略。
可以避免使用多重条件选择语句（如if...else或switch...case）。
提高了算法的复用性和灵活性。

策略模式适用于以下场景：

当一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现时。
当需要在不同的情况下使用不同的策略，或者策略还可能在未来用其他方式来实现时。

以下是一个简单的C++实现的策略模式（Strategy Pattern）示例：

c 复制代码

#include <iostream>

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

// 具体策略A
class ConcreteStrategyA : public Strategy {
public:
    void algorithmInterface() override {
        std::cout << "Strategy A's algorithm..." << std::endl;
    }
};

// 具体策略B
class ConcreteStrategyB : public Strategy {
public:
    void algorithmInterface() override {
        std::cout << "Strategy B's algorithm..." << std::endl;
    }
};

// 上下文
class Context {
public:
    Context(Strategy* strategy) : strategy_(strategy) {}
    ~Context() { delete strategy_; }
    void contextInterface() {
        strategy_->algorithmInterface();
    }

private:
    Strategy* strategy_;
};

int main() {
    Context* contextA = new Context(new ConcreteStrategyA());
    contextA->contextInterface();

    Context* contextB = new Context(new ConcreteStrategyB());
    contextB->contextInterface();

    delete contextA;
    delete contextB;

    return 0;
}

在这个例子中，Strategy是抽象策略，定义了algorithmInterface接口。ConcreteStrategyA和ConcreteStrategyB是具体策略，实现了algorithmInterface接口。

Context是上下文，它维护了一个对策略对象的引用，这个引用可以是抽象策略类，也可以是具体策略类。在contextInterface接口中，上下文会调用策略的algorithmInterface接口。

通过这种方式，我们可以动态地改变上下文的策略，从而改变上下文的行为。

帮助理解：

算法的定义和使用是分开的。

Context类中引用算法的抽象类。

客户端可以根据情况使用Context类设置"算法的具体类"来覆盖"算法的抽象类"。