**策略模式(Strategy Pattern)**是一种行为型设计模式,它定义了一系列算法,将每一个算法封装起来,并使它们可以互相替换,策略模式让算法可以独立于使用它的客户端而变化。这意味着,客户端可以根据需要动态选择使用哪种算法,而不需要修改算法的实现。
策略模式的主要组成部分
- 策略接口(Strategy Interface):定义了所有具体策略类需要实现的算法接口。
- 具体策略类(Concrete Strategy Classes):实现了策略接口中定义的算法。
- 上下文类(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++开发中,策略模式可用于需要灵活切换算法或行为的场景,例如不同的绘图引擎、数据处理策略等。