前言：

随着 C++11 的发布，C++ 标准引入了许多新特性，使语言更加现代化，开发者编写的代码也变得更加简洁和易于维护。Lambda 表达式是其中一个重要的特性，它提供了一种方便的方式来定义匿名函数，这在函数式编程范式中非常常见。Lambda 表达式允许我们在函数内部定义小型的无名函数，减少了不必要的函数定义和代码冗余，是现代 C++ 开发的重要工具。

本文将详细介绍 C++11 中 Lambda 表达式的语法、使用场景、捕获机制以及高级应用，帮助读者充分理解并应用这个特性。

一、Lambda 表达式的基础

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

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

• capture（捕获列表）：定义了哪些外部变量会被“捕获”并在 lambda 表达式内部使用。它可以按值或按引用捕获。
• parameters（参数列表）：与普通函数的参数列表相似，定义了传递给 lambda 的参数。
• return_type（返回类型）：指定返回类型，C++11 可以自动推导返回类型，因此该部分可以省略。
• body（函数体）：lambda 实际执行的代码块。

一个简单的 Lambda 表达式示例：

auto add = [](int a, int b) -> int {
    return a + b; };
std::cout << add(5, 3) << std::endl;  // 输出 8

这里我们定义了一个接受两个 int 参数并返回它们之和的匿名函数。lambda 通过 [] 定义了捕获列表，(int a, int b) 是参数列表，-> int 是返回类型，而函数体 { return a + b; } 执行了实际的操作。

二、捕获列表

捕获列表定义了 lambda 可以使用的外部变量。捕获方式分为两种：按值捕获和按引用捕获。通过不同的捕获方式，可以控制 lambda 对外部变量的访问和修改行为。

1. 不捕获任何变量

如果 lambda 不需要使用任何外部变量，可以使用空捕获列表：

auto sayHello = []() {
    std::cout << "Hello, World!" << std::endl; };
sayHello();  // 输出：Hello, World!

2. 按值捕获（=）

按值捕获意味着 lambda 内部得到的是捕获变量的副本，因此在 lambda 内对该变量的修改不会影响外部变量。

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

在上面的例子中，虽然我们在 lambda 定义之后修改了 x 的值，但 lambda 捕获的是 x 的副本，因此输出的仍然是 10。

3. 按引用捕获（&）

按引用捕获则允许 lambda 直接访问外部变量并修改它的值。

int x = 10;
auto captureByReference = [&x]() {
    x += 10; };
captureByReference();
std::cout << x << std::endl;  // 输出 20

这里我们通过 &x 将 x 按引用捕获，因此在 lambda 中对 x 的修改会直接影响外部变量。

4. 捕获特定变量

可以只捕获特定的变量，而不是捕获所有外部变量。捕获方式可以是按值或按引用：

int a = 5, b = 10;
auto captureSpecific = [a, &b]() {
   
    std::cout << "a: " << a << std::endl;
    std::cout << "b: " << b << std::endl;
    b = 20;
};
captureSpecific();
std::cout << "b: " << b << std::endl;  // 输出 20

在这个例子中，a 被按值捕获，b 被按引用捕获。lambda 内部修改了 b，而外部的 b 也受到了影响。

5. 捕获所有变量（[=] 和 [&]）

• [=]：按值捕获所有外部变量。
• [&]：按引用捕获所有外部变量。

int x = 5, y = 10;
auto captureAllByValue = [=]() {
   
    std::cout << "x: " << x << ", y: " << y << std::endl;
};
captureAllByValue();  // 输出：x: 5, y: 10

auto captureAllByReference = [&]() {
   
    x += 10;
    y += 10;
};
captureAllByReference();
std::cout << "x: " << x << ", y: " << y << std::endl;  // 输出：x: 15, y: 20

通过 [=]，lambda 按值捕获了 x 和 y，因此即使在外部修改了 x 和 y，lambda 内的 x 和 y 仍然保持不变。而通过 [&]，lambda 可以直接修改外部的 x 和 y。

三、Lambda 表达式的返回类型

在 C++11 中，lambda 的返回类型可以自动推导，也可以显式指定。通常，如果 lambda 体中只有一个 return 语句，编译器会自动推导返回类型：

auto add = [](int a, int b) {
    return a + b; };
std::cout << add(3, 4) << std::endl;  // 输出 7

如果 lambda 体中有复杂的逻辑或多个 return 语句，建议使用 -> 明确指定返回类型：

auto complexLambda = [](int a, int b) -> int {
   
    if (a > b) return a;
    else return b;
};
std::cout << complexLambda(3, 4) << std::endl;  // 输出 4

自动推导有时会导致问题，特别是当 lambda 返回一个引用或指针时，明确返回类型显得尤为重要。

四、Lambda 的常见使用场景

1. 用于标准算法

C++ 标准库中提供了许多算法，如 std::sort、std::for_each 等，lambda 可以很方便地作为这些算法的回调函数使用。

std::vector<int> v = {
   1, 2, 3, 4, 5};
std::for_each(v.begin(), v.end(), [](int &n) {
    n *= 2; });
for (auto n : v) std::cout << n << " ";  // 输出 2 4 6 8 10

在这个例子中，lambda 作为 std::for_each 的参数，将每个元素乘以 2。

2. 用于排序

使用 lambda 作为自定义排序条件，可以让排序更加灵活。

std::vector<int> v = {
   5, 2, 9, 1, 5, 6};
std::sort(v.begin(), v.end(), [](int a, int b) {
    return a > b; });
for (auto n : v) std::cout << n << " ";  // 输出 9 6 5 5 2 1

这里，我们通过 lambda 定义了一个降序排序的条件。

3. 用于事件回调

在 GUI 或网络编程中，lambda 常用于定义事件的回调函数。例如，在按钮点击事件中：

button.onClick([]() {
   
    std::cout << "Button clicked!" << std::endl;
});

lambda 作为回调函数的使用使得代码更加简洁。

五、Lambda 表达式的高级用法

1. 捕获 this 指针

在类成员函数中，lambda 可以通过 [this] 捕获当前对象的 this 指针，这样就可以访问类的成员变量和成员函数。

class MyClass {
   
public:
    int value = 42;

    void printValue() {
   
        auto lambda = [this]() {
   
            std::cout << "Value: " << value << std::endl;
        };
        lambda();
    }
};

int main() {
   
    MyClass obj;
    obj.printValue();  // 输出：Value: 42
}

通过捕获 this 指针，lambda 可以访问和修改对象的成员。

2. 可变的 Lambda 表达式

默认情况下，lambda 是不可修改其捕获的值的。如果需要修改捕获的值，可以在捕获列表后加上 mutable 关键字：

int

 x = 10;
auto mutableLambda = [x]() mutable {
   
    x += 10;
    std::cout << "Inside lambda: " << x << std::endl;
};
mutableLambda();
std::cout << "Outside lambda: " << x << std::endl;  // 输出：Outside lambda: 10

mutable 使得 x 可以在 lambda 内部被修改，但不会影响外部的 x。

六、结语

C++11 的 Lambda 表达式为开发者提供了一种高效、简洁的方式来定义匿名函数，极大地增强了 C++ 的表达能力。理解并掌握 lambda 的使用方式，将有助于写出更现代、更易读的 C++ 代码 参考。