C++中Lambda表达式的神奇之处：从基础到进阶的深入探讨-CSDN博客

本文链接：https://blog.csdn.net/m0_57781768/article/details/133312811

第一部分：Lambda表达式的基础

Lambda表达式，也被称为匿名函数，在C++11开始引入。它允许我们在代码中直接定义一个小的、未命名的函数。Lambda表达式在很多情况下都非常有用，比如当我们使用STL的算法时，或者想要创建一些一次性的小函数。

1. Lambda表达式的基本形式

Lambda表达式的基本形式如下：

[捕获列表](参数列表) -> 返回类型 {
    // 函数体
};

其中，只有函数体是必须的。其他部分可以根据情况省略。

例如，下面是一个简单的Lambda，它没有参数，不返回任何值，并输出一个字符串：

auto simpleLambda = []() {
    std::cout << "Hello from Lambda!" << std::endl;
};

simpleLambda(); // 输出：Hello from Lambda!

2. 捕获列表

捕获列表定义了哪些外部变量可以被Lambda表达式访问。我们可以按值或按引用捕获变量。

按值捕获：Lambda保存变量的一个副本。
按引用捕获：Lambda保存对变量的引用。

例如：

int a = 10;
int b = 20;

// 按值捕获
auto sumByValue = [a, b]() {
    return a + b;
};
std::cout << sumByValue() << std::endl; // 输出：30

// 按引用捕获
auto sumByReference = [&a, &b]() {
    return a + b;
};
std::cout << sumByReference() << std::endl; // 输出：30

3. 参数列表和返回类型

Lambda表达式可以接受参数和返回值，就像普通的函数一样。

例如，考虑以下用于加法的Lambda：

auto add = [](int x, int y) -> int {
    return x + y;
};

std::cout << add(10, 20) << std::endl; // 输出：30

在上面的例子中，Lambda接受两个int类型的参数，返回它们的和。注意，我们可以省略返回类型，并让编译器推断它，但在这里为了清晰起见，我们明确地指定了返回类型。

4. 使用Lambda的实际场景

Lambda表达式在很多情况下都非常有用。例如，当我们想要在STL算法中使用自定义比较函数时，Lambda可以让代码更简洁。

std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};

// 使用Lambda进行排序
std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
    return a > b; // 降序排序
});

for (int num : numbers) {
    std::cout << num << " ";
}
// 输出：9 6 5 5 5 4 3 3 2 1 1

到此为止，我们已经讨论了Lambda表达式的基础内容，包括其定义、捕获列表、参数和返回类型，以及它们在实际中的应用。

第二部分：Lambda表达式的进阶用法

在深入了解Lambda表达式的基础知识后，我们现在将探讨其更加高级的功能和用法。

5. 默认捕获模式

默认捕获模式可以使我们更简洁地指定捕获列表。两种默认捕获模式是=（按值捕获）和&（按引用捕获）。当你使用默认捕获模式时，你仍然可以为特定的变量提供显式模式。

例如：

int a = 10, b = 20, c = 30;

// 默认按值捕获，但显式地按引用捕获c
auto sum = [=, &c]() {
    c = a + b;
    return c;
};
std::cout << sum() << std::endl;  // 输出：30
std::cout << c << std::endl;      // 输出：30

6. 嵌套Lambda

Lambda表达式可以嵌套。这意味着一个Lambda内部可以定义并使用另一个Lambda。

例如：

auto outerLambda = [](int x) {
    return [x](int y) {
        return x + y;
    };
};

auto innerLambda = outerLambda(5);
std::cout << innerLambda(10) << std::endl;  // 输出：15

在这个示例中，outerLambda返回另一个Lambda，该Lambda随后被用来添加两个数字。

7. Lambda与`std::function`

Lambda表达式的类型是编译器定义的，并且不容易直接表示。但我们可以使用std::function来存储和操作Lambda。

例如：

#include <functional>

std::function<int(int, int)> add = [](int x, int y) {
    return x + y;
};

std::cout << add(10, 20) << std::endl;  // 输出：30

这使得Lambda更容易在函数之间传递，作为返回值，或存储在容器中。

8. Lambda的状态：可变Lambda

默认情况下，按值捕获的变量在Lambda内部是常量，不能被修改。但我们可以通过在Lambda参数列表之后添加mutable关键字来改变这种行为。

int x = 5;

auto modify = [x]() mutable {
    x += 10;
    return x;
};

std::cout << modify() << std::endl;  // 输出：15
std::cout << x << std::endl;         // 输出：5（外部的x仍然是5，因为它是按值捕获的）

到目前为止，我们已经涵盖了Lambda表达式的许多进阶特性。它们增强了Lambda的灵活性，使其成为C++中非常强大的工具。

第三部分：深入探讨Lambda的更多特性及应用场景

在前面的部分中，我们详细了解了Lambda的基本和进阶特性。现在，我们将更深入地探讨Lambda的特点和它在实际编程中的应用。

9. Lambda的类型和`decltype`

每个Lambda表达式都有其自己独特的类型。这意味着，即使两个Lambda具有完全相同的功能和形式，它们的类型也是不同的。我们可以使用decltype来检查Lambda的类型，尽管这种类型是编译器生成的，通常不直接使用。

auto lambda1 = []() {};
auto lambda2 = []() {};

static_assert(!std::is_same_v<decltype(lambda1), decltype(lambda2)>, "Lambdas have different types!");

10. Lambda在并行和并发编程中的应用

C++为并行算法提供了支持，其中Lambda经常作为并行任务的一部分使用。例如，我们可以使用Lambda表达式轻松地进行并行化的计算：

#include <vector>
#include <algorithm>
#include <execution>

std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

std::for_each(std::execution::par, data.begin(), data.end(), [](int& value) {
    value *= 2;  // Double each value
});

for (const auto& v : data) {
    std::cout << v << " ";  // Outputs: 2 4 6 8 10 12 14 16 18 20
}
std::cout << std::endl;

在上述代码中，我们使用了并行版本的std::for_each以及C++中的并行执行策略，有效地将任务分配到多个线程上。

11. 泛型Lambdas

C++14引入了泛型Lambda，它可以接受自动推导的参数类型：

auto genericAdd = [](auto x, auto y) {
    return x + y;
};

std::cout << genericAdd(5, 10) << std::endl;       // Outputs: 15
std::cout << genericAdd(5.5, 10.5) << std::endl;  // Outputs: 16
std::cout << genericAdd(std::string("Hello, "), "Lambda!") << std::endl;  // Outputs: Hello, Lambda!