策略模式（C++）

简介

策略模式是一种行为型设计模式，它定义了一系列的算法，并将每一个算法封装起来，使它们可以相互替换，且不影响客户端的使用。策略模式的目的是将算法的使用与实现分离，降低了算法之间的耦合，提高了代码的可扩展性和可维护性。

策略模式适用于以下场景：

• 当有多种算法可以实现同一个功能，但是客户端需要根据不同的情况选择不同的算法时，可以使用策略模式。
• 当一个类定义了多种行为，且这些行为在这个类的操作中以多个条件语句的形式出现时，可以使用策略模式将每个行为封装为一个策略类，消除这些条件语句。
• 当一个系统需要动态地在几种算法中选择一种时，可以使用策略模式。

策略模式的常用技巧有：

• 定义一个抽象策略接口，用于规范所有具体策略类的行为。
• 定义一个上下文类，用于维护一个策略对象的引用，并提供一个方法让客户端可以设置或更换策略对象。
• 定义一系列具体策略类，实现抽象策略接口，并封装各自的算法逻辑。
• 客户端通过创建上下文对象，并传入具体策略对象，来使用不同的算法。客户端可以在运行时更换策略对象，实现动态切换算法的功能。

策略模式是一种简单而有效的设计模式，它可以帮助我们实现高内聚低耦合的代码设计原则，提高系统的灵活性和可复用性。

C++示例

#include <iostream>
#include <vector>
#include <algorithm>

// 定义排序策略接口
class SortStrategy {
public:
    virtual void sort(std::vector<int>& nums) = 0;
};

// 实现冒泡排序策略
class BubbleSort : public SortStrategy {
public:
    void sort(std::vector<int>& nums) override {
        int n = nums.size();
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    std::swap(nums[j], nums[j + 1]);
                }
            }
        }
    }
};

// 实现快速排序策略
class QuickSort : public SortStrategy {
public:
    void sort(std::vector<int>& nums) override {
        quickSort(nums, 0, nums.size() - 1);
    }

private:
    void quickSort(std::vector<int>& nums, int left, int right) {
        if (left >= right) {
            return;
        }
        int pivot = partition(nums, left, right);
        quickSort(nums, left, pivot - 1);
        quickSort(nums, pivot + 1, right);
    }

    int partition(std::vector<int>& nums, int left, int right) {
        int pivot = nums[right];
        int i = left;
        for (int j = left; j < right; j++) {
            if (nums[j] < pivot) {
                std::swap(nums[i], nums[j]);
                i++;
            }
        }
        std::swap(nums[i], nums[right]);
        return i;
    }
};

// 定义排序类，使用策略模式
class Sorter {
public:
    Sorter(SortStrategy* strategy) : strategy_(strategy) {}

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

    void sort(std::vector<int>& nums) {
        strategy_->sort(nums);
    }

private:
    SortStrategy* strategy_;
};

int main() {
    std::vector<int> nums = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
    Sorter sorter(new BubbleSort());
    sorter.sort(nums);
    for (int num : nums) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    sorter.setStrategy(new QuickSort());
    sorter.sort(nums);
    for (int num : nums) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}