C++ 策略模式 - 技术栈

策略模式概述

策略模式（Strategy Pattern）是一种行为设计模式，允许在运行时选择算法的行为。它将算法封装在独立的类中，使得它们可以互相替换，而不影响使用算法的客户端代码。

策略模式结构

策略模式通常包含以下角色：

Context：维护一个对策略对象的引用，通过接口与策略对象交互。
Strategy：定义所有支持的算法的公共接口。
ConcreteStrategy：实现具体算法的类。

实现示例

以下是一个简单的C++实现示例，展示如何使用策略模式实现不同的排序算法：

cpp 复制代码

#include <iostream>
#include <vector>

// Strategy接口
class SortStrategy {
public:
    virtual void sort(std::vector<int>& data) = 0;
    virtual ~SortStrategy() = default;
};

// ConcreteStrategy: 冒泡排序
class BubbleSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        std::cout << "Sorting using Bubble Sort" << std::endl;
        // 实现冒泡排序逻辑
        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]);
                }
            }
        }
    }
};

// ConcreteStrategy: 快速排序
class QuickSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        std::cout << "Sorting using Quick Sort" << std::endl;
        // 实现快速排序逻辑
        quickSort(data, 0, data.size() - 1);
    }

private:
    void quickSort(std::vector<int>& data, int low, int high) {
        if (low < high) {
            int pivot = partition(data, low, high);
            quickSort(data, low, pivot - 1);
            quickSort(data, pivot + 1, high);
        }
    }

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

// Context类
class Sorter {
private:
    SortStrategy* strategy;

public:
    Sorter(SortStrategy* strategy) : strategy(strategy) {}

    void setStrategy(SortStrategy* newStrategy) {
        strategy = newStrategy;
    }

    void sort(std::vector<int>& data) {
        strategy->sort(data);
    }
};

// 客户端代码
int main() {
    std::vector<int> data = {5, 2, 9, 1, 5, 6};

    BubbleSort bubbleSort;
    QuickSort quickSort;

    Sorter sorter(&bubbleSort);
    sorter.sort(data);

    // 输出排序结果
    for (int num : data) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 切换策略
    sorter.setStrategy(&quickSort);
    sorter.sort(data);

    // 输出排序结果
    for (int num : data) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

策略模式优点

算法可以自由切换，只需修改策略对象即可。
避免使用多重条件判断语句，提高代码可维护性。
扩展性好，增加新策略只需添加新的策略类，无需修改现有代码。

策略模式适用场景

一个系统需要动态地在几种算法中选择一种。
有多个条件语句的类，每个分支对应不同的算法行为。
需要封装算法，使得算法可以独立于使用它的客户端变化。

注意事项

客户端必须了解所有策略类的区别，以便选择合适的策略。
策略模式会增加系统中对象的数量，可以通过共享策略对象来减少开销。