策略模式 (Strategy Pattern)

策略模式 (Strategy Pattern)

意图：定义一系列算法，将它们封装起来，并使它们可以互相替换。策略模式使算法独立于使用它的客户端而变化。

基础组件

• Strategy (策略)：定义所有支持的算法的公共接口
• ConcreteStrategy (具体策略)：实现策略接口的具体算法
• Context (上下文)：维护对策略对象的引用，并将请求委托给策略

继承/实现关系

Strategy <|-- ConcreteStrategyA
Strategy <|-- ConcreteStrategyB
Context --> Strategy (组合关系)

应用场景

• 需要在运行时选择不同算法
• 需要避免使用多重条件判断
• 需要封装算法，使客户端与算法解耦

C++ 实现（导航系统场景）

#include <iostream>
#include <string>
#include <algorithm>
#include <memory>
#include <vector>

/*
* 策略模式
* 意图：定义一系列算法，将它们封装起来，并使它们可以互相替换。策略模式使算法独立于使用它的客户端而变化。
* 基础组件：
* - Strategy (策略)：定义所有支持的算法的公共接口
* - ConcreteStrategy (具体策略)：实现策略接口的具体算法
* - Context (上下文)：维护对策略对象的引用，并将请求委托给策略
* 继承/实现关系：
* ConcreteStrategyA/B/C 类继承自 Strategy 接口。
* Context 类持有 Strategy 接口的引用，可以在运行时切换不同的策略（ConcreteStrategyA/B/C）。
*/

// 策略接口：排序算法
class SortStrategy {
public:
    virtual ~SortStrategy() = default;
    virtual void sort(std::vector<int>& data) = 0;
    virtual std::string getName() const = 0;
};

// 具体策略：快速排序
class QuickSortStrategy : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        std::cout << "Performing quick sort...\n";
        quickSort(data, 0, data.size() - 1);
    }

    std::string getName() const override {
        return "Quick Sort";
    }

private:
    void quickSort(std::vector<int>& data, int low, int high) {
        if (low < high) {
            int pi = partition(data, low, high);
            quickSort(data, low, pi - 1);
            quickSort(data, pi + 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 - 1; j++) {
            if (data[j] < pivot) {
                i++;
                std::swap(data[i], data[j]);
            }
        }
        std::swap(data[i + 1], data[high]);
        return i + 1;
    }
};

// 具体策略：归并排序
class MergeSortStrategy : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        std::cout << "Performing merge sort...\n";
        mergeSort(data, 0, data.size() - 1);
    }

    std::string getName() const override {
        return "Merge Sort";
    }

private:
    void mergeSort(std::vector<int>& data, int left, int right) {
        if (left < right) {
            int mid = left + (right - left) / 2;
            mergeSort(data, left, mid);
            mergeSort(data, mid + 1, right);
            merge(data, left, mid, right);
        }
    }

    void merge(std::vector<int>& data, int left, int mid, int right) {
        int n1 = mid - left + 1;
        int n2 = right - mid;

        std::vector<int> L(n1), R(n2);

        for (int i = 0; i < n1; i++)
            L[i] = data[left + i];
        for (int j = 0; j < n2; j++)
            R[j] = data[mid + 1 + j];

        int i = 0, j = 0, k = left;

        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                data[k] = L[i];
                i++;
            }
            else {
                data[k] = R[j];
                j++;
            }
            k++;
        }

        while (i < n1) {
            data[k] = L[i];
            i++;
            k++;
        }

        while (j < n2) {
            data[k] = R[j];
            j++;
            k++;
        }
    }
};

// 具体策略：冒泡排序
class BubbleSortStrategy : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        std::cout << "Performing bubble sort...\n";
        int n = data.size();
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (data[j] > data[j + 1]) {
                    std::swap(data[j], data[j + 1]);
                }
            }
        }
    }

    std::string getName() const override {
        return "Bubble Sort";
    }
};

// 上下文：排序处理器
class SortContext {
public:
    explicit SortContext(std::unique_ptr<SortStrategy> strategy = nullptr)
        : strategy_(std::move(strategy)) {}

    void setStrategy(std::unique_ptr<SortStrategy> strategy) {
        strategy_ = std::move(strategy);
    }

    void performSort(std::vector<int>& data) {
        if (!strategy_) {
            std::cout << "No sorting strategy selected!\n";
            return;
        }

        std::cout << "Using strategy: " << strategy_->getName() << "\n";
        strategy_->sort(data);
    }

    void display(const std::vector<int>& data) {
        std::cout << "Sorted data: ";
        for (int num : data) {
            std::cout << num << " ";
        }
        std::cout << "\n";
    }

private:
    std::unique_ptr<SortStrategy> strategy_;
};

void StrategyPattern()
{
	std::cout << std::string(13, '-') << " Strategy Pattern " << std::string(13, '-') << "\n";

    // 创建测试数据
    std::vector<int> data = { 64, 34, 25, 12, 22, 11, 90 };

    // 创建排序上下文
    SortContext sorter;

    // 使用快速排序
    sorter.setStrategy(std::make_unique<QuickSortStrategy>());
    std::vector<int> data1 = data;
    sorter.performSort(data1);
    sorter.display(data1);

    // 使用归并排序
    sorter.setStrategy(std::make_unique<MergeSortStrategy>());
    std::vector<int> data2 = data;
    sorter.performSort(data2);
    sorter.display(data2);

    // 使用冒泡排序
    sorter.setStrategy(std::make_unique<BubbleSortStrategy>());
    std::vector<int> data3 = data;
    sorter.performSort(data3);
    sorter.display(data3);
}