策略模式通过封装算法族实现灵活替换，核心为策略接口、具体策略和上下文三部分，避免条件判断，支持运行时动态切换算法，符合开闭原则，提升代码可维护性与扩展性。
在C++中，策略模式是一种行为设计模式，它允许你定义一系列算法，并将每种算法封装起来，使它们可以互换使用。这种模式让算法的变化独立于使用它的客户端，特别适合需要动态切换算法或行为的场景。
策略模式的核心思想：算法族的封装与替换
策略模式通过将算法抽象为独立的类，使它们可以彼此替换，而无需修改使用算法的上下文代码。这样做的好处是：
- 避免大量条件判断语句（如 if-else 或 switch）来选择算法
- 算法可以独立变化，新增或修改算法不影响现有代码
- 运行时可动态切换算法
典型结构与实现方式
策略模式通常包含三个部分：
- 策略接口（Strategy）：定义所有支持算法的公共接口
- 具体策略（Concrete Strategy）：实现策略接口的具体算法类
- 上下文（Context）：持有策略对象，调用其方法执行算法
示例代码：
立即学习“C++免费学习笔记（深入）”；
假设我们要实现不同排序算法的切换：
#include <iostream>
#include <vector>
#include <algorithm>
<p>// 策略接口
class SortStrategy {
public:
virtual ~SortStrategy() = default;
virtual void sort(std::vector<int>& data) = 0;
};</p><p>// 具体策略：快速排序
class QuickSort : public SortStrategy {
public:
void sort(std::vector<int>& data) override {
std::cout << "使用快速排序\n";
std::sort(data.begin(), data.end());
}
};</p><p>// 具体策略：冒泡排序（适用于小数据）
class BubbleSort : public SortStrategy {
public:
void sort(std::vector<int>& data) override {
std::cout << "使用冒泡排序\n";
for (size_t i = 0; i < data.size(); ++i)
for (size_t j = 0; j < data.size() - i - 1; ++j)
if (data[j] > data[j+1])
std::swap(data[j], data[j+1]);
}
};</p><p>// 上下文
class Sorter {
private:
SortStrategy<em> strategy_;
public:
explicit Sorter(SortStrategy</em> strategy) : strategy_(strategy) {}</p><pre class='brush:php;toolbar:false;'>void setStrategy(SortStrategy* strategy) {
strategy_ = strategy;
}
void performSort(std::vector<int>& data) {
if (strategy_)
strategy->sort(data);
}};
使用示例：
int main() {
std::vector<int> data = {5, 2, 9, 1, 5, 6};
<pre class='brush:php;toolbar:false;'>QuickSort quickSort;
BubbleSort bubbleSort;
Sorter sorter(&quickSort);
sorter.performSort(data); // 输出：使用快速排序
sorter.setStrategy(&bubbleSort);
sorter.performSort(data); // 输出：使用冒泡排序
return 0;}
应用场景与优势
策略模式特别适用于以下情况：
- 有多个相似类，仅行为不同
- 需要在运行时切换算法
- 算法使用了难以公开的数据，封装后更安全
- 想避免使用多重条件判断选择行为
优势包括：
- 提高代码可维护性：新增算法只需添加新类
- 符合开闭原则：对扩展开放，对修改关闭
- 算法可独立测试
基本上就这些。策略模式通过将算法封装成对象，实现灵活替换，是处理算法族切换的优雅方式。在C++中结合多态和指针/引用，能高效实现这一模式，同时保持良好的性能和扩展性。不复杂但容易忽略细节，比如内存管理和虚析构函数的使用。
