【C++11】lambda表达式

前言：

随着 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: 10auto 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 关键字：

intx = 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