C++怎么实现一个策略模式_C++设计模式与策略模式实现

策略模式通过封装不同算法并使其可互换，提升代码灵活性；示例中Sorter上下文调用不同排序策略，体现多态与开闭原则。

策略模式是一种行为型设计模式，它让你定义一系列算法或行为，并将每种行为封装在独立的类中，使它们可以互换使用。在C++中实现策略模式，关键在于通过基类指针调用派生类的虚函数，从而实现运行时多态。

策略模式的核心结构

策略模式包含三个主要角色：

Strategy（策略接口）： 定义所有支持算法的公共接口，通常是一个抽象基类，含有一个纯虚函数。
ConcreteStrategy（具体策略）： 实现Strategy接口的具体类，每个类代表一种算法。
Context（上下文）： 持有一个Strategy对象的引用或指针，客户端通过Context来使用具体的策略。

一个简单的C++实现示例

假设我们要实现不同的排序策略（如冒泡排序、快速排序），可以这样设计：

// 策略接口 class SortStrategy { public: virtual ~SortStrategy() = default; virtual void sort(std::vector& data) const = 0; };

// 具体策略：冒泡排序 class BubbleSort : public SortStrategy { public: void sort(std::vector& data) const override { for (size_t i = 0; i data[j+1]) std::swap(data[j], data[j+1]); } };

// 具体策略：快速排序 class QuickSort : public SortStrategy { public: void sort(std::vector& data) const override { quickSortImpl(data, 0, data.size() - 1); }

private: void quickSortImpl(std::vector& arr, int low, int high) const { if (low

int partition(std::vector& arr, int low, int high) const {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; ++j) {
        if (arr[j] <= pivot) {
            ++i;
            std::swap(arr[i], arr[j]);
        }
    }
    std::swap(arr[i + 1], arr[high]);
    return i + 1;
}

};

// 上下文类 class Sorter { private: const SortStrategy* strategy;

public: explicit Sorter(const SortStrategy* strat = nullptr) : strategy(strat) {}

void setStrategy(const SortStrategy* strat) {
    strategy = strat;
}

void performSort(std::vector& data) const {
    if (strategy)
        strategy->sort(data);
}

};

如何使用这个策略模式

客户端代码可以根据需要动态切换排序算法：

int main() { std::vector data = {64, 34, 25, 12, 22, 11, 90};

Sorter sorter;

// 使用冒泡排序
BubbleSort bubble;
sorter.setStrategy(&bubble);
sorter.performSort(data);
// 此时 data 已排序

// 切换为快速排序
QuickSort quick;
sorter.setStrategy(&quick);
sorter.performSort(data);

return 0;

}

这种设计让算法的变化独立于使用它的客户端，符合开闭原则——对扩展开放，对修改关闭。