C++11 核心特性：Lambda 表达式与函数包装器详解

捕获列表详解

捕获列表决定了 Lambda 如何访问其所在作用域的变量。

int main() {
    int x = 10, y = 20;
    auto f1 = [=]() { return x + y; };      // 值捕获
    auto f2 = [&]() { x += y; };            // 引用捕获，修改外部变量
    auto f3 = [x, &y]() { y += x; };        // 混合捕获
    return 0;
}

提示：如果在函数局部定义 Lambda，它可以捕获位置之前定义的变量。静态局部变量和全局变量无需捕获即可直接使用。若 Lambda 定义在全局作用域，捕获列表必须为空。

mutable 关键字

默认情况下，Lambda 捕获列表中的值是被 const 修饰的，这意味着值捕获的变量在 Lambda 内部是只读的。如果需要修改副本，需添加 mutable 关键字：

int main() {
    int a = 5;
    auto f = [a]() mutable {
        a += 10; // 修改的是 a 的拷贝，不影响外部 a
        std::cout << a << std::endl;
    };
    f(); // 输出 15
    std::cout << a << std::endl; // 输出 5
    return 0;
}

实际应用场景

1. 与 STL 算法结合

std::vector<int> vec = {1, 2, 3, 4, 5};
std::for_each(vec.begin(), vec.end(), [](int x) {
    std::cout << x << " ";
});

2. 条件查找

auto it = std::find_if(vec.begin(), vec.end(), [](int x) {
    return x > 3;
});
if (it != vec.end()) {
    std::cout << *it; // 输出 4
}

3. 排序自定义规则

std::sort(vec.begin(), vec.end(), [](int a, int b) {
    return a > b; // 降序
});

Lambda 的原理

从底层实现来看，Lambda 表达式类似于范围 for 循环。编译后，它们并没有直接的对应指令，而是被转换为仿函数对象（Functor）。

简单来说，每写一个 Lambda，编译器就会生成一个对应的仿函数类。这个类的类名由编译器按规则生成，确保唯一性。Lambda 的参数、返回值和函数体分别对应仿函数 operator() 的参数、返回类型和函数体。而捕获列表的本质则是生成的仿函数成员变量。

• 值捕捉：仿函数的成员是对捕捉变量的值拷贝。
• 引用捕捉：仿函数的成员是对捕捉变量的引用。

隐式捕捉机制则更加智能，编译器会根据实际使用情况决定传递哪些对象（用多少捕捉多少）。

函数包装器

std::function

std::function 是一个类模板，充当通用包装器。它可以存储并调用任何可调用对象，包括函数指针、仿函数、Lambda 表达式以及 bind 表达式。这些被称为 std::function 的目标。

如果 std::function 不含目标，调用时会抛出 std::bad_function_call 异常。

#include <functional>

int main() {
    std::function<int(int, int)> func;
    func = [](int a, int b) { return a + b; };
    std::cout << func(3, 4) << std::endl; // 输出 7
    return 0;
}

std::function 的核心优势在于统一接口。无论是函数指针、仿函数还是 Lambda，只要签名（返回值和参数）一致，就可以被同一个 std::function 对象包装。这在需要回调或作为参数传递时非常有用。

int fun(int a, int b) { return a + b; }

struct Functor {
    int operator()(int a, int b) { return a + b; }
};

class Plus {
public:
    static int plusi(int a, int b) { return a + b; }
    double plusd(double a, double b) { return (a + b) * _n; }
private:
    int _n = 10;
};

int main() {
    std::function<int(int, int)> f1 = fun;           // 函数指针
    std::function<int(int, int)> f2 = Functor();     // 仿函数
    std::function<int(int, int)> f3 = [](int a, int b){return a + b;}; // Lambda

    std::cout << f1(1, 1) << std::endl;
    std::cout << f2(1, 1) << std::endl;
    std::cout << f3(1, 1) << std::endl;

    // 包装静态成员函数
    std::function<int(int, int)> f4 = &Plus::plusi;
    std::cout << f4(1, 1) << std::endl;

    // 包装非静态成员函数
    // 注意：非静态成员函数隐含 this 指针，调用时需传入对象或指针
    std::function<double(Plus*, double, double)> f5 = &Plus::plusd;
    Plus pd;
    std::cout << f5(&pd, 1.1, 1.1) << std::endl;

    // 或者通过 bind 绑定对象
    std::function<double(double, double)> f6 = std::bind(&Plus::plusd, pd, _1, _2);
    std::cout << f6(1.1, 1.1) << std::endl;

    return 0;
}

优化案例：逆波兰表达式求值

在处理如逆波兰表达式（RPN）这类需要根据运算符动态选择逻辑的场景时，直接写大量的 switch-case 会显得冗长且难以扩展。利用 std::function 配合 map 可以大幅简化代码。

原始写法通常需要大量分支判断，而优化后的方案将运算符映射到对应的可调用对象上：

class Solution {
public:
    int evalRPN(std::vector<std::string>& tokens) {
        std::stack<int> st;
        // 使用 map 存储运算符与对应的 lambda 表达式
        std::map<std::string, std::function<int(int, int)>> mp = {
            {"+", [](int x, int y) { return x + y; }},
            {"-", [](int x, int y) { return x - y; }},
            {"*", [](int x, int y) { return x * y; }},
            {"/", [](int x, int y) { return x / y; }}
        };

        for (auto& e : tokens) {
            if (mp.count(e)) {
                int right = st.top(); st.pop();
                int left = st.top(); st.pop();
                st.push(mp[e](left, right));
            } else {
                st.push(std::stoi(e));
            }
        }
        return st.top();
    }
};

这种方式不仅让代码更简洁，后续增加新运算符也只需在 map 中新增条目即可。

bind 与占位符

std::bind 是另一个强大的工具，用于调整参数个数和顺序。它本质上是一个函数适配器。

int Fun(int a, int b) { return (a - b) * 10; }

int main() {
    // _1 代表第一个实参，_2 代表第二个实参
    auto fun1 = std::bind(Fun, _1, _2);         // Fun(10, 5)
    auto fun2 = std::bind(Fun, _2, _1);         // Fun(5, 10)
    auto fun3 = std::bind(Fun, 100, _1);        // Fun(100, 5)
    auto fun4 = std::bind(Fun, _1, 100);        // Fun(5, 100)

    std::cout << fun1(10, 5) << std::endl;
    std::cout << fun2(10, 5) << std::endl;
    std::cout << fun3(5) << std::endl;
    std::cout << fun4(5) << std::endl;

    return 0;
}

当处理非静态成员函数时，std::function 包装往往需要显式传递对象实例，这有时显得繁琐。此时结合 std::bind 可以预先绑定对象，从而简化调用：

class Plus {
public:
    double plusd(double a, double b) { return (a + b) * _n; }
private:
    int _n = 10;
};

// 使用 bind 锁定对象，调用时无需再传 this
std::function<double(double, double)> f = std::bind(&Plus::plusd, Plus(), _1, _2);
std::cout << f(1.1, 1.1) << std::endl;

通过组合使用 Lambda、std::function 和 std::bind，我们可以构建出高度灵活且易于维护的可调用对象体系。