C++ lambda 表达式：匿名函数的使用场景

C++ lambda 表达式（匿名函数）是 C++11 引入的一个强大特性，它允许你在需要函数的地方直接定义函数，而无需单独命名。这种写法不仅让代码更加紧凑，还能显著提高代码的可读性和维护性。以下指南将详细拆解 lambda 表达式的语法结构，并通过实际场景演示如何正确使用它。

1. 理解 Lambda 表达式的核心语法

在使用 lambda 表达式之前，必须熟悉其基本构成。一个标准的 lambda 表达式包含以下部分：

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

• 捕获列表：定义如何从外部作用域获取变量（值传递或引用传递）。
• 参数列表：与普通函数的参数列表一致，若没有参数可省略。
• 返回类型：指定返回值类型，若编译器能自动推断则可省略。
• 函数体：包含具体的执行代码。

编写 一个最简单的 lambda 表达式示例：

auto greet = []() {
    printf("Hello, Lambda!\n");
};

// 调用
greet();

2. 场景一：配合标准库算法进行自定义排序

这是 lambda 表达式最常用的场景。当使用 std::sort 或 std::find_if 等标准库算法时，如果排序规则或查找条件比较特殊，定义一个独立的命名函数往往会显得代码分散。

假设有一个 Student 结构体列表，现在需要按照学生的分数进行降序排序。

1. 定义 Student 结构体：

struct Student {
    std::string name;
    int score;
};

2. 创建 一个包含多个学生的 std::vector 容器。
3. 调用 std::sort 并传入 lambda 表达式作为比较准则：

#include <algorithm>
#include <vector>
#include <string>

std::vector<Student> students = {
    {"Alice", 85},
    {"Bob", 95},
    {"Charlie", 78}
};

// 使用 lambda 进行排序
std::sort(students.begin(), students.end(), [](const Student& a, const Student& b) {
    return a.score > b.score; // 降序排列
});

通过这种方式，排序逻辑紧跟在排序调用之后，阅读 代码时无需跳转到其他文件查看比较函数的定义。

3. 场景二：捕获外部变量进行灵活计算

Lambda 表达式的强大之处在于它可以“捕获”其定义所在作用域内的变量。这允许你在匿名函数内部使用外部数据，实现类似“闭包”的功能。

假设你需要计算一个数组中所有元素相对于某个基准值的偏移量之和。

1. 设定 一个基准值 base_value。
2. 定义 lambda 表达式，并在捕获列表 [] 中指定捕获方式。

捕获方式通常有以下几种，请参考下表：

3. 执行 以下代码演示引用捕获的使用：

int base_value = 10;
int sum = 0;

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

// 引用捕获 base_value 和 sum
std::for_each(numbers.begin(), numbers.end(), [&base_value, &sum](int n) {
    sum += (n + base_value);
});

// 此时 sum 的值变成了 (1+10) + (2+10) + ... + (5+10) = 75

在此示例中，lambda 表达式直接修改了外部变量 sum，省去了定义额外函数来传递状态的麻烦。

4. 场景三：多线程编程中的任务传递

在 C++11 及以上版本中，std::thread 构造函数可以直接接收一个可调用对象。Lambda 表达式非常适合用来快速定义线程要执行的任务代码块。

1. 包含 <thread> 头文件。
2. 创建 一个 lambda 表达式作为线程的入口函数。
3. 启动 线程并传入 lambda。

#include <thread>
#include <iostream>

// 准备要传递给线程的数据
int data = 100;

// 启动线程，lambda 按值捕获 data
std::thread t([data]() {
    // 这里是在新线程中运行
    std::cout << "Thread running with data: " << data << std::endl;
});

// 等待线程结束
t.join();

使用 lambda 可以避免为每一个简单的后台任务编写独立的函数，使得线程启动代码和任务逻辑紧密耦合，便于调试。

5. 场景四：智能指针的自定义删除器

在使用 std::unique_ptr 管理非堆内存（如文件句柄、网络连接等）资源时，通常需要指定自定义的删除器。Lambda 表达式提供了一种轻量级的方式来实现这种定制。

1. 定义 一个文件指针类型的 unique_ptr，并指定删除器类型。
2. 在 构造函数中传入 lambda 表达式来处理资源释放。

#include <memory>
#include <cstdio>

// 定义一个自定义删除器类型的 unique_ptr
// 删除器是一个 lambda，接收 FILE* 并关闭它
auto file_closer = [](FILE* f) {
    if (f) {
        std::printf("Closing file...\n");
        fclose(f);
    }
};

std::unique_ptr<FILE, decltype(file_closer)> file_ptr(fopen("test.txt", "w"), file_closer);

if (file_ptr) {
    fprintf(file_ptr.get(), "Hello World");
}
// 当 file_ptr 离开作用域时，file_closer lambda 会被自动调用

这种用法确保了资源管理逻辑（如何关闭文件）与资源使用逻辑在同一个代码块中定义，防止了忘记编写专门的删除器类或函数。

6. 进阶技巧：使用 mutable 修改值捕获的变量

默认情况下，以值传递方式捕获的变量在 lambda 内部是 const 的，不可修改。如果需要在 lambda 内部修改这些副本（注意：不影响外部变量），必须使用 mutable 关键字。

1. 编写 一个带 mutable 关键字的 lambda。
2. 观察 内部计数器的变化。

int counter = 0;

// 注意 mutable 关键字的位置
auto increment = [counter]() mutable {
    counter++; // 允许修改副本
    printf("Inside lambda: %d\n", counter);
};

increment(); // 输出 1
increment(); // 输出 2

printf("Outside lambda: %d\n", counter); // 输出 0，外部值未变

在需要维护局部状态但又不希望影响外部变量的场景下（例如生成唯一序列号），这种技巧非常实用。