Qt C++设计模式-＞策略模式

**策略模式（Strategy Pattern）**是一种行为型设计模式，它定义了一系列算法，将每一个算法封装起来，并使它们可以互相替换，策略模式让算法可以独立于使用它的客户端而变化。这意味着，客户端可以根据需要动态选择使用哪种算法，而不需要修改算法的实现。

策略模式的主要组成部分

1. 策略接口（Strategy Interface）：定义了所有具体策略类需要实现的算法接口。
2. 具体策略类（Concrete Strategy Classes）：实现了策略接口中定义的算法。
3. 上下文类（Context Class）：维护对策略对象的引用，客户端通过上下文类与具体的策略对象进行交互，上下文类会将具体策略的实现委托给策略对象。

策略模式的优点

• 可以动态地改变对象的行为，方便扩展新策略。
• 避免了多重条件判断语句，算法或行为分离封装。

策略模式的缺点

• 客户端必须了解所有策略，并自行决定使用哪一个策略。
• 策略模式会增加类的数量。

策略模式的UML类图

  +---------------------+
  |       Context        |
  +---------------------+
  | - strategy: Strategy |
  +---------------------+
  | + setStrategy(Strategy): void |
  | + executeStrategy(): void     |
  +---------------------+
              |
              |
    +-----------------+
    |     Strategy     | <--- 抽象接口
    +-----------------+
    | + algorithm(): void |
    +-----------------+
        /      |     \
       /       |      \
  +---------+  +---------+  +---------+
  | Concrete|  | Concrete|  | Concrete|
  |Strategy1|  |Strategy2|  |Strategy3|
  +---------+  +---------+  +---------+

策略模式示例：Qt C++ 小Demo

我们将构建一个简单的示例，展示如何使用策略模式选择不同的算法来执行计算。在这个例子中，我们使用策略模式来实现不同的数学运算策略，如加法、减法和乘法。

1. 定义策略接口（Strategy Interface）

首先定义一个策略接口，声明不同运算需要实现的算法接口：

class Strategy {
public:
    virtual ~Strategy() {}
    virtual int execute(int a, int b) = 0;
};

2. 实现具体策略类（Concrete Strategy Classes）

然后，我们实现具体的策略类，如加法、减法和乘法：

class AddStrategy : public Strategy {
public:
    int execute(int a, int b) override {
        return a + b;
    }
};

class SubtractStrategy : public Strategy {
public:
    int execute(int a, int b) override {
        return a - b;
    }
};

class MultiplyStrategy : public Strategy {
public:
    int execute(int a, int b) override {
        return a * b;
    }
};

3. 上下文类（Context Class）

上下文类持有一个策略的引用，并且可以在运行时动态地改变策略：

class Context {
private:
    Strategy* strategy;

public:
    Context(Strategy* strategy = nullptr) : strategy(strategy) {}

    void setStrategy(Strategy* strategy) {
        this->strategy = strategy;
    }

    int executeStrategy(int a, int b) {
        if (strategy)
            return strategy->execute(a, b);
        return 0; // 默认返回值
    }
};

4. 使用策略模式

现在我们可以编写客户端代码，动态选择不同的策略来执行计算：

#include <iostream>

int main() {
    Context context;

    // 设置为加法策略
    AddStrategy addStrategy;
    context.setStrategy(&addStrategy);
    std::cout << "5 + 3 = " << context.executeStrategy(5, 3) << std::endl;

    // 设置为减法策略
    SubtractStrategy subtractStrategy;
    context.setStrategy(&subtractStrategy);
    std::cout << "5 - 3 = " << context.executeStrategy(5, 3) << std::endl;

    // 设置为乘法策略
    MultiplyStrategy multiplyStrategy;
    context.setStrategy(&multiplyStrategy);
    std::cout << "5 * 3 = " << context.executeStrategy(5, 3) << std::endl;

    return 0;
}

输出结果：

5 + 3 = 8
5 - 3 = 2
5 * 3 = 15

关键点

• 上下文类Context负责维护策略，并可以动态更改策略。
• 每个具体的策略类实现了不同的算法（加法、减法、乘法）。
• 通过策略模式，客户端可以方便地替换策略，而不需要修改上下文类的代码

总结

策略模式通过将不同的算法封装为独立的类，便于在运行时动态替换这些算法。在Qt C++开发中，策略模式可用于需要灵活切换算法或行为的场景，例如不同的绘图引擎、数据处理策略等。