当前位置：首页 > article >正文

策略模式 - 策略模式的使用

article 2025/1/26 17:38:48

引言

在软件开发中，设计模式是解决常见问题的经典解决方案。策略模式（Strategy Pattern）是行为型设计模式之一，它允许在运行时选择算法的行为。通过将算法封装在独立的类中，策略模式使得算法可以独立于使用它的客户端而变化。本文将详细介绍策略模式的概念、结构、实现以及在C++中的应用。

策略模式的概念

策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互换。策略模式使得算法可以独立于使用它的客户端而变化。换句话说，策略模式允许在运行时选择算法的行为，而不是在编译时。

策略模式的结构

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

Context（上下文）：持有一个策略类的引用，用于调用具体的策略。
Strategy（策略）：定义所有支持的算法的公共接口。
ConcreteStrategy（具体策略）：实现策略接口的具体算法。

策略模式的实现

下面我们通过一个简单的例子来演示如何在C++中实现策略模式。

示例：排序策略

假设我们有一个应用程序，需要对一组数据进行排序。我们可以使用不同的排序算法（如冒泡排序、快速排序等）来实现排序功能。通过策略模式，我们可以在运行时选择使用哪种排序算法。

1. 定义策略接口

首先，我们定义一个策略接口 SortStrategy，它包含一个纯虚函数 sort，用于执行排序操作。

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

2. 实现具体策略

接下来，我们实现两个具体的排序策略：BubbleSortStrategy 和 QuickSortStrategy。

class BubbleSortStrategy : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        // 实现冒泡排序算法
        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]);
                }
            }
        }
    }
};

class QuickSortStrategy : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        // 实现快速排序算法
        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;
    }
};

3. 定义上下文类

然后，我们定义一个上下文类 SortContext，它持有一个 SortStrategy 的指针，并在需要时调用具体的排序策略。

class SortContext {
public:
    SortContext(SortStrategy* strategy) : strategy_(strategy) {}

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

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

private:
    SortStrategy* strategy_;
};

4. 使用策略模式

最后，我们可以在客户端代码中使用策略模式来动态选择排序算法。

int main() {
    std::vector<int> data = {5, 2, 9, 1, 5, 6};

    BubbleSortStrategy bubbleSort;
    QuickSortStrategy quickSort;

    SortContext context(&bubbleSort);
    context.executeSort(data);

    std::cout << "Bubble Sort Result: ";
    for (int num : data) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    context.setStrategy(&quickSort);
    context.executeSort(data);

    std::cout << "Quick Sort Result: ";
    for (int num : data) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}