C++中如何实现策略模式 函数对象与lambda表达式应用

策略模式的核心在于定义并封装可互换的算法族，通过函数对象和lambda实现动态选择。1. 策略接口定义算法行为；2. 具体策略类或lambda实现算法；3. 上下文类持有并调用策略。使用lambda更简洁，适合简单逻辑；函数对象适合复杂场景。过度设计需避免，仅在策略多、复杂且需解耦时使用。

策略模式的核心在于定义一系列算法，并将每个算法封装起来，使它们可以互相替换。在C++中，函数对象（Functors）和Lambda表达式是实现策略模式的强大工具，它们允许我们在运行时动态地选择算法。

解决方案

C++中实现策略模式，通常会涉及到以下几个关键部分：策略接口、具体策略类、以及上下文类。策略接口定义了算法族共同的行为，具体策略类实现了这些行为，而上下文类则负责维护一个策略对象，并在运行时调用它。使用函数对象和Lambda表达式，可以简化策略类的定义，并增加灵活性。

立即学习“C++免费学习笔记（深入）”；

红墨

一站式小红书图文生成器

下载

#include 
#include 
#include 

// 策略接口 (使用std::function)
using SortingStrategy = std::function&)>;

// 上下文类
class Sorter {
public:
    Sorter(SortingStrategy strategy) : sortingStrategy(strategy) {}

    void sort(std::vector& data) {
        sortingStrategy(data);
    }

    void setStrategy(SortingStrategy strategy) {
        sortingStrategy = strategy;
    }

private:
    SortingStrategy sortingStrategy;
};

// 具体策略 (Lambda 表达式)
auto bubbleSort = [](std::vector& data) {
    std::cout << "Using Bubble Sort" << std::endl;
    // Bubble Sort 实现 (简化)
    for (size_t i = 0; i < data.size() - 1; ++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]);
            }
        }
    }
};

auto quickSort = [](std::vector& data) {
    std::cout << "Using Quick Sort (std::sort)" << std::endl;
    // 使用 std::sort 实现快速排序
    std::sort(data.begin(), data.end());
};

int main() {
    std::vector numbers = {5, 2, 8, 1, 9, 4};

    // 使用 Bubble Sort
    Sorter sorter(bubbleSort);
    sorter.sort(numbers);
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    numbers = {5, 2, 8, 1, 9, 4}; // 重置数据

    // 切换到 Quick Sort
    sorter.setStrategy(quickSort);
    sorter.sort(numbers);
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

函数对象 vs Lambda 表达式：选择哪个？

函数对象是重载了 operator() 的类，而Lambda表达式是匿名函数。两者都可以作为策略传递给上下文。Lambda表达式通常更简洁，尤其是在策略逻辑比较简单的情况下。函数对象则更适合复杂的策略，可以封装更多的状态和行为。选择哪个取决于策略的复杂度和可读性需求。有时候，我会先用 Lambda 实现一个简单的策略，然后如果发现逻辑变得复杂，就重构为一个函数对象。

策略模式在实际项目中的应用场景

策略模式在需要动态切换算法的场景中非常有用。比如，一个图像处理程序可能需要支持多种图像压缩算法（JPEG, PNG, GIF），用户可以在运行时选择使用哪种算法。又或者，一个游戏 AI 可能需要根据不同的游戏状态选择不同的策略（进攻、防守、逃跑）。在这些场景下，策略模式可以避免大量的 if-else 或 switch 语句，使代码更清晰、更易于维护。

如何避免策略模式过度设计？

过度设计是设计模式使用中常见的问题。在应用策略模式时，需要考虑以下几点：

• 策略的数量： 如果策略的数量很少（比如只有 1-2 个），并且不太可能增加，那么可能没有必要使用策略模式。直接使用 if-else 或 switch 语句可能更简单。
• 策略的复杂性： 如果策略的逻辑非常简单，那么使用 Lambda 表达式可能就足够了，不需要创建单独的策略类。
• 上下文的耦合度： 确保上下文类只依赖于策略接口，而不是具体的策略类。这样可以降低耦合度，使代码更易于测试和维护。

我曾经在一个项目中，为了“以防万一”使用了策略模式，结果后来发现只需要一个策略，导致代码变得过于复杂。所以，记住 YAGNI (You Ain't Gonna Need It) 原则，只在真正需要的时候才应用设计模式。