C++ lambda用法

C++ Lambda 表达式详解

Lambda 表达式是 C++11 引入的一项重要特性，允许开发者在函数内部定义匿名函数对象，极大地简化了代码逻辑，尤其适用于需要传递小型函数作为参数的场景（如 STL 算法、线程任务等）。

✅ 一、基本语法

Lambda 表达式的完整语法如下：

[capture-list] (parameter-list) mutable -> return-type { function-body }

各部分说明如下：

✅ 二、捕获列表（Capture List）

捕获列表用于指定 Lambda 表达式可以访问的外部变量。

1. 按值捕获（By Value）

int x = 10;
auto lambda = [x]() { std::cout << x << std::endl; };
x = 20;
lambda(); // 输出 10（捕获的是 x 的拷贝）

• Lambda 内部保存的是变量的副本，外部变量修改不影响内部副本。

2. 按引用捕获（By Reference）

int y = 30;
auto lambda = [&y]() { std::cout << y << std::endl; };
y = 40;
lambda(); // 输出 40（捕获的是 y 的引用）

• Lambda 内部保存的是变量的引用，外部变量修改会影响内部。

3. 隐式捕获（Implicit Capture）

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

int a = 1, b = 2;
auto sum = [=]() { return a + b; }; // 按值捕获 a 和 b

4. 混合捕获

• 指定部分变量按值，部分变量按引用

int c = 5, d = 6;
auto func = [c, &d]() { return c + d; }; // c 按值，d 按引用

✅ 三、参数列表（Parameter List）

Lambda 表达式的参数列表与普通函数类似，支持任意类型的参数。

示例：带参数的 Lambda

auto multiply = [](int a, int b) -> int {
    return a * b;
};

std::cout << multiply(3, 4) << std::endl; // 输出 12

• -> int 是可选的返回类型声明，若省略，编译器会自动推导（C++11 要求返回类型一致）。

✅ 四、mutable 关键字

默认情况下，按值捕获的变量在 Lambda 内部是不可修改的。如果希望修改，需使用 mutable 关键字。

int value = 100;
auto increment = [value]() mutable {
    value += 10;
    std::cout << value << std::endl;
};
increment(); // 输出 110
std::cout << value << std::endl; // 输出 100（外部变量未被修改）

✅ 五、返回类型（Return Type）

1. 自动推导（C++11）

如果 Lambda 体内只有一个 return 语句，编译器可以自动推导返回类型。

auto square = [](int x) { return x * x; }; // 自动推导为 int

2. 显式声明返回类型

当 Lambda 体内有多个 return 语句或需要指定特定类型时，应使用尾置返回类型。

auto divide = [](double a, double b) -> double {
    if (b != 0) return a / b;
    else return 0.0;
};

✅ 六、应用场景

1. STL 算法中的使用

Lambda 表达式常用于 STL 算法中，作为谓词或操作函数。

示例：排序

#include <vector>
#include <algorithm>

std::vector<int> nums = {5, 2, 9, 1, 5, 6};
std::sort(nums.begin(), nums.end(), [](int a, int b) {
    return a > b; // 降序排序
});

示例：筛选偶数

nums.erase(
    std::remove_if(nums.begin(), nums.end(), [](int x) {
        return x % 2 != 0;
    }),
    nums.end()
);

2. 作为回调函数

Lambda 表达式非常适合用于定义一次性使用的回调逻辑。

#include <functional>
#include <iostream>

void execute(std::function<void()> task) {
    task();
}

int main() {
    execute([]() {
        std::cout << "Task executed!" << std::endl;
    });
    return 0;
}

✅ 七、与函数对象（Functor）对比

✅ 八、进阶特性（C++14+）

1. 泛型 Lambda（Generic Lambda）

使用 auto 作为参数类型，支持任意类型的输入。

auto add = [](auto a, auto b) {
    return a + b;
};

std::cout << add(3, 4) << std::endl;      // int
std::cout << add(2.5, 3.5) << std::endl;  // double

2. 初始化捕获（Init Capture）

允许在捕获列表中初始化新变量（C++14 起）。

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

✅ 九、注意事项

✅ 十、总结一句话

Lambda 表达式是 C++ 中一种灵活、简洁的匿名函数对象机制，支持捕获外部变量、参数传递、返回类型推导等功能，广泛应用于 STL 算法、回调函数、线程任务等场景，是现代 C++ 编程中不可或缺的工具。