前言：Lambda表达式是C++ 11引入的一个重要新特性之一。它是一个匿名函数对象，可直接在调用的地方定义，无需声明。

目录

一、Lambda表达式的特点及好处

二、Lamda表达式的基本语法及解析

三、底层原理

四、常见应用场景

4.1 与STL库配合使用

4.2 回调与事件处理

4.3 泛型Lambda(C++14)

4.4 移动捕获与初始化捕获(C++14)

五、一些注意事项

---

一、Lambda表达式的特点及好处

特点：短小精悍（不适合复杂的函数逻辑）

好处：1）可读性强，易于理解：阅读者不需要通过上下文或其他文件中去查找对应的实现

           2）简洁清晰：可省略函数名和类名，直接定义和使用，使得代码更加简洁和清晰

           3）可简化回调函数

二、Lamda表达式的基本语法及解析

[capture-list](parameters) mutable noexcept -> return-type {
    // 函数体
}

含义：

a. 捕获列表(capture-list)：如何访问外部变量（按值捕获或者按引用捕获），不可省略。

b. 参数列表(parameters)：与普通函数的参数列表含义一致，无参数时可省略。

c. mutable(可选）：默认情况下，按值捕获的变量在Lambda内部是const，加上mutable可修改其副本（但不影响外部变量）。

d. noexcept(可选)：声明函数不会抛出异常。

e. 返回类型(->return-type, 可选)：若函数体仅有一条return语句，编译器可自动推导返回类型，否则需显示指定。

f. 函数体：Lambda的逻辑。

常用捕获列表：

• [ ]：不捕获任何外部变量。
• [=]：按值捕获所有外部变量（会产生副本，修改不影响外部）。
• [&]：按引用捕获所有外部变量（修改会影响外部）。
• [x]：仅按值捕获变量x。
• [&y]：仅按引用捕获变量y。
• [=, &z]：除z按引用捕获外，其余按值捕获。
• [&, x]：除x按值捕获外，其余按引用捕获。
• [this]：在类成员函数中，捕获当前对象。

三、底层原理

Lambda表达式本质上是一个函数对象（Functor），即重载了函数调用运算符operator()的类实例。

编译器会根据Lambda的定义，在内部生成一个相应的匿名类，并将Lambda表达式转换为该匿名类的一个临时对象。

当你定义一个 lambda 表达式时，其实编译器会默默做以下三件事：

1. 创建一个类：生成一个唯一的类名（通常包含 lambda 字样和一些随机字符）
2. 添加成员变量：如果你捕获了外部变量（按值捕获或按引用捕获），编译器会在该类中添加对应的成员变量来存储这些值。
3. 重载 operator()：将 lambda 的函数体放入该类的operator() 函数中，使得该类的对象可以像函数一样被调用。

举一个简单例子，假如有一个这样的Lambda表达式：

#include <iostream>
void example() {
    int base = 10;
    // 定义一个 lambda，按值捕获 base
    auto add = [base](int a) {
        return base + a;
    };
    int result = add(20); // 调用 lambda
    std::cout << "Result: " << result << std::endl; // 输出 30
}

编译器在内部会将其转换为类似于下面的代码：

#include <iostream>
// 编译器生成的匿名类（名字是小栈随意造的，实际会更复杂）
class __Lambda_1234 {
public:
    // 1. 按值捕获的变量变成了构造函数的参数和成员变量
    __Lambda_1234(int _base) : base(_base) {}
    // 2. lambda 的函数体变成了 operator()
    // 注意：默认情况下 operator() 是 const 的，意味着 lambda 体内不能修改按值捕获的变量
    int operator()(int a) const {
        return base + a;
    }
private:
    int base; // 捕获的变量作为成员变量存储在这里
};

void example() {
    int base = 10;
    // 定义 lambda 变量，实际上是实例化了上面的类
    __Lambda_1234 add(base); 
    // 调用 lambda，实际上是调用了对象的 operator()
    int result = add(20); 
    std::cout << "Result: " << result << std::endl;
}

四、常见应用场景

4.1 与STL库配合使用

最普遍的使用场景，避免因为简单比较等逻辑而编写冗长的函数

#include <algorithm>
#include <vector>
#include <iostream>
int main() {
    std::vector<int> nums = {5, 2, 8, 1, 9};

    // 自定义排序（降序）
    std::sort(nums.begin(), nums.end(), 
              [](int a, int b) { return a > b; });

    // for_each 配合 Lambda 进行遍历
    std::for_each(nums.begin(), nums.end(),
                  [](int x) { std::cout << x << " "; });
}

4.2 回调与事件处理

Lambda可以作为函数对象传递给需要回调的接口，从而省去单独编写命名函数的麻烦。这在事件处理场景尤为常见。

例如，在GUI编程中，使用Lambda处理按钮点击事件：

button->onClicked([]() {
    // 按钮点击时执行的代码
    std::cout << "Button clicked!" << std::endl;
});

4.3 泛型Lambda(C++14)

使用 auto 参数实现类似模板的效果，提高代码复用性。

#include <iostream>
#include <vector>
int main() {
    // 泛型 Lambda，自动推导参数类型
    auto print = [](const auto& container) {
        for (const auto& elem : container) {
            std::cout << elem << " ";
        }
        std::cout << "\n";
    };

    std::vector<int> vec = {1, 2, 3};

    print(vec); // 适用于 vector

4.4 移动捕获与初始化捕获(C++14)

允许在捕获列表中为捕获的变量提供一个初始化表达式。语法格式：在捕获列表中输入： 捕获的变量名 = 初始化表达式。

#include <iostream>
#include <memory>
#include <vector>
#include <algorithm>
int main() {
    auto ptr = std::make_unique<int>(42);

    // 移动捕获：将 unique_ptr 移入 Lambda
    auto lambda = [p = std::move(ptr)]() {
        std::cout << "Value: " << *p << "\n";
    };

    // ptr 现在为空，资源已被 Lambda 接管
    lambda(); // 输出 Value: 42

    // 复杂初始化：计算并捕获中间结果
    int x = 10;
    auto compute = [y = x * x + 5]() {
        return y; // 捕获的是 105，而非计算表达式
    };
}

五、一些注意事项

使用Lambda需要注意一些细节，避免引入潜在的问题。

• 捕获变量的生命周期：捕获变量时必须确保Lambda的生命周期不会超出所捕获变量的生命周期，否则可能访问已销毁的对象，导致某些未定义行为。

• 默认捕获：尽量避免使用默认捕获模式[=]与[&]。默认捕获虽然方便，但可能导致无意中捕获了不必要的变量，或者因变量名拼写错误而捕获了错误的变量。显示捕获（如：[x, &y]），更有指向性。

• 调试Lambda：由于Lambda的类型在源码中不可见，调试Lambda表达式可能具有挑战性，且调试器可能显示为匿名类型。通常可以借助编译器扩展工具（如 LLVM的C++ Insights来查看编译器为Lambda生成的等价代码）。