怎样设计C++中的策略模式函数对象与lambda表达式的现代实现-C++-PHP中文网

怎样设计C++中的策略模式函数对象与lambda表达式的现代实现

P粉602998670

发布： 2025-08-15 12:29:01

原创

731人浏览过

策略模式在c++++中通过函数对象和lambda表达式实现，可提升灵活性与代码简洁性。1. 定义策略接口提高可读性和维护性；2. 使用函数对象实现有状态或复杂逻辑的策略；3. 使用lambda表达式实现无状态且简单的策略；4. 通过上下文类维护策略并在运行时动态切换；5. 客户端根据需求传递不同策略。函数对象适合复杂逻辑，lambda适合简洁实现，策略模式适用于排序算法、支付系统等需动态选择算法的场景，但应避免过度设计。

怎样设计C++中的策略模式函数对象与lambda表达式的现代实现

策略模式在C++中的实现，核心在于定义一系列算法，并将每一个算法封装起来，使它们可以互相替换。函数对象（Functors）和 Lambda 表达式是实现策略模式的现代且灵活的方式。

策略模式允许在运行时选择算法，避免了使用大量的条件语句。

解决方案

在C++中，使用函数对象和Lambda表达式实现策略模式，可以获得更高的灵活性和代码简洁性。下面展示如何通过这些技术实现策略模式：

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

定义策略接口（可选）：

虽然不是强制性的，但定义一个策略接口可以提高代码的可读性和可维护性，尤其是在策略比较复杂时。
```
class Strategy {
public:
    virtual int execute(int a, int b) = 0;
    virtual ~Strategy() = default;
};
```
登录后复制

使用函数对象实现策略：

函数对象是重载了

operator()

登录后复制

的类。它们可以像函数一样被调用，并且可以携带状态。

class AdditionStrategy {
public:
    int execute(int a, int b) {
        return a + b;
    }
};

class SubtractionStrategy {
public:
    int execute(int a, int b) {
        return a - b;
    }
};

登录后复制

使用 Lambda 表达式实现策略：

北极象沉浸式AI翻译
免费的北极象沉浸式AI翻译 - 带您走进沉浸式AI的双语对照体验

0

查看详情

Lambda 表达式提供了一种更简洁的方式来定义策略。
```
auto multiplicationStrategy = [](int a, int b) { return a * b; };
auto divisionStrategy = [](int a, int b) {
    if (b == 0) throw std::runtime_error("Division by zero!");
    return a / b;
};
```
登录后复制

上下文类：

上下文类维护一个指向策略的指针或函数对象，并提供一个方法来执行策略。

#include <functional>
#include <iostream>

class Context {
private:
    std::function<int(int, int)> strategy; // 使用 std::function

public:
    Context(std::function<int(int, int)> strategy) : strategy(strategy) {}

    int executeStrategy(int a, int b) {
        return strategy(a, b);
    }

    void setStrategy(std::function<int(int, int)> newStrategy) {
        strategy = newStrategy;
    }
};

登录后复制

客户端代码：

客户端代码创建上下文对象，并将不同的策略传递给它。

int main() {
    AdditionStrategy add;
    SubtractionStrategy subtract;

    Context contextAdd([&](int a, int b){ return add.execute(a, b); });
    std::cout << "Addition: " << contextAdd.executeStrategy(5, 3) << std::endl;

    Context contextSubtract([&](int a, int b){ return subtract.execute(a, b); });
    std::cout << "Subtraction: " << contextSubtract.executeStrategy(5, 3) << std::endl;

    // 使用 Lambda 表达式
    Context contextMultiply([](int a, int b) { return a * b; });
    std::cout << "Multiplication: " << contextMultiply.executeStrategy(5, 3) << std::endl;

    Context contextDivide([](int a, int b) {
        if (b == 0) throw std::runtime_error("Division by zero!");
        return a / b;
    });

    try {
        std::cout << "Division: " << contextDivide.executeStrategy(10, 2) << std::endl;
        //std::cout << "Division by zero: " << contextDivide.executeStrategy(10, 0) << std::endl; // 会抛出异常
    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
    }

    // 动态切换策略
    contextAdd.setStrategy([](int a, int b) { return a * a + b * b; });
    std::cout << "Dynamic Strategy: " << contextAdd.executeStrategy(2, 3) << std::endl;

    return 0;
}

登录后复制