C++ lambda表达式

C++ 中的 Lambda 表达式是 C++11 引入的一个重要特性，它允许我们在代码中创建匿名的函数对象，提供了一种简洁且灵活的方式来定义局部的、一次性使用的函数。下面从多个方面详细讲解 Lambda 表达式的原理。

1. 基本语法和形式

Lambda 表达式的基本语法如下：

[capture](parameters) mutable(optional) exception(optional) -> return_type(optional) { body }

• [capture]：捕获列表，用于指定 Lambda 表达式可以访问的外部变量。捕获方式有值捕获（如 [var]）、引用捕获（如 [&var]）、隐式值捕获（如 [=]）、隐式引用捕获（如 [&]）等。
• (parameters)：参数列表，和普通函数的参数列表类似。
• mutable（可选）：如果使用该关键字，那么 Lambda 表达式内部可以修改值捕获的变量。
• exception（可选）：异常说明，用于指定 Lambda 表达式可能抛出的异常。
• -> return_type（可选）：返回类型，编译器通常可以自动推导返回类型，所以很多时候可以省略。
• { body }：函数体，包含 Lambda 表达式要执行的代码。

2. 底层实现原理

本质是匿名函数对象

Lambda 表达式在底层是通过编译器自动生成一个匿名的类（函数对象，也称为仿函数）来实现的。这个类重载了函数调用运算符 operator()，使得该类的对象可以像函数一样被调用。以下是一个简单的 Lambda 表达式及其对应的可能生成的类的示例：

#include <iostream>

int main() {
    int x = 10;
    // Lambda 表达式
    auto lambda = [x](int y) { return x + y; };
    std::cout << lambda(5) << std::endl;

    // 等效的函数对象类
    class __lambda_3_11 {
    public:
        __lambda_3_11(int _x) : x(_x) {}

        int operator()(int y) const {
            return x + y;
        }

    private:
        int x;
    };

    __lambda_3_11 func(x);
    std::cout << func(5) << std::endl;

    return 0;
}

在这个例子中，[x](int y) { return x + y; } 这个 Lambda 表达式会被编译器转换为一个类似 __lambda_3_11 的匿名类。这个类有一个构造函数用于初始化捕获的变量 x，并且重载了 operator() 来实现 Lambda 表达式的函数体逻辑。

捕获列表的处理

• 值捕获：当使用值捕获（如 [x]）时，编译器会在生成的匿名类中添加一个与捕获变量类型相同的成员变量，并在类的构造函数中对其进行初始化。这样，Lambda 表达式内部使用的是捕获变量的副本，即使外部变量的值发生改变，Lambda 表达式内部的副本也不会受影响。例如：

#include <iostream>

int main() {
    int x = 10;
    auto lambda = [x]() { return x; };
    x = 20;
    std::cout << lambda() << std::endl; // 输出 10
    return 0;
}

• 引用捕获：使用引用捕获（如 [&x]）时，编译器会在生成的匿名类中添加一个引用类型的成员变量，该引用指向外部变量。因此，Lambda 表达式内部对该变量的修改会影响到外部变量，反之亦然。例如：

#include <iostream>

int main() {
    int x = 10;
    auto lambda = [&x]() { x = 20; };
    lambda();
    std::cout << x << std::endl; // 输出 20
    return 0;
}

• 隐式捕获：隐式值捕获 [=] 表示捕获所有外部变量的值，编译器会在匿名类中为每个被捕获的变量添加一个对应的成员变量并初始化。隐式引用捕获 [&] 表示捕获所有外部变量的引用，编译器会添加对应的引用类型成员变量。

mutable 关键字的作用

如果 Lambda 表达式使用了 mutable 关键字，那么生成的 operator() 就不会是 const 成员函数。这意味着 Lambda 表达式内部可以修改值捕获的变量。例如：

#include <iostream>

int main() {
    int x = 10;
    auto lambda = [x]() mutable { x = 20; std::cout << x << std::endl; };
    lambda();
    std::cout << x << std::endl; // 外部的 x 仍然是 10
    return 0;
}

在这个例子中，由于使用了 mutable，Lambda 表达式内部可以修改值捕获的变量 x 的副本，但外部的 x 不受影响。

返回类型推导

编译器通常可以根据 Lambda 表达式的函数体自动推导返回类型。如果函数体只有一个 return 语句，返回类型就是该 return 语句表达式的类型；如果函数体有多个 return 语句，这些语句的返回类型必须相同，否则需要显式指定返回类型。例如：

#include <iostream>

int main() {
    // 自动推导返回类型为 int
    auto lambda1 = [](int x) { return x + 1; };

    // 显式指定返回类型为 double
    auto lambda2 = [](int x) -> double { return static_cast<double>(x) / 2; };

    std::cout << lambda1(5) << std::endl;
    std::cout << lambda2(5) << std::endl;

    return 0;
}

3. 性能考虑

Lambda 表达式的性能和普通函数对象类似，因为它们本质上都是通过函数调用运算符来实现的。由于 Lambda 表达式生成的是内联函数对象，在大多数情况下，编译器可以对其进行很好的优化，使得调用 Lambda 表达式的开销和调用普通函数相差不大。

4. 与标准库的结合使用

Lambda 表达式在 C++ 标准库中得到了广泛的应用，特别是在算法库中。例如，可以使用 Lambda 表达式作为 std::sort 函数的比较函数：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {3, 1, 4, 1, 5, 9};
    std::sort(numbers.begin(), numbers.end(), [](int a, int b) { return a < b; });
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

在这个例子中，Lambda 表达式 [](int a, int b) { return a < b; } 作为比较函数传递给 std::sort，用于指定元素的排序规则。

综上所述，C++ 的 Lambda 表达式通过编译器生成匿名函数对象来实现，捕获列表用于处理外部变量的访问，mutable 关键字和返回类型推导等特性增加了其灵活性，并且在标准库中有着广泛的应用。