C++ Lambda 表达式详解

核心规则：值捕获的本质是「拷贝」。lambda 内部拿到的是外部变量的副本，无论外部变量后续如何修改，lambda 内部的副本都不会变；默认是只读的。

3. 引用捕获 [&变量名] 或 [&]

单个引用捕获 [&a, &b]

int a = 10, b = 20;
auto func = [&a, &b]() {
    a++; b++;
    cout << "a=" << a << ", b=" << b << endl; // 输出：11 21
};
func();
cout << "外部 a=" << a << endl; // 输出：11，原变量被修改

全部引用捕获 [&]

int a = 10, b = 20;
string s = "hello lambda";
auto func = [&]() {
    a++; s += "!";
    cout << a << " " << b << " " << s << endl;
};
func();
cout << "外部 s=" << s << endl; // 输出：hello lambda!

核心规则：引用捕获的本质是「取别名」。对 lambda 内部的变量修改，会直接修改原变量。注意必须保证被引用的外部变量生命周期大于等于 lambda 的生命周期，否则会出现野引用。

4. 混合捕获

场景：需要捕获多个外部变量，一部分只读（值捕获）、一部分需要修改（引用捕获）。

int a = 10, b = 20, c = 30;
// 写法：[=, &a] 含义：所有变量默认「值捕获」，但变量 a 单独「引用捕获」
auto func1 = [=, &a]() {
    a++; // a 是引用，可修改原变量
    cout << a << " " << b << " " << c << endl;
};
func1();

// 写法：[&, b] 含义：所有变量默认「引用捕获」，但变量 b 单独「值捕获」
auto func2 = [& , b]() {
    a++; c++; // a、c 是引用，可修改
    // b++; 报错！b 是值捕获，只读
    cout << a << " " << b << " " << c << endl;
};
func2();

混合捕获规则：

• [=, &变量名]：优先值捕获所有，指定变量单独引用捕获。
• [&, 变量名]：优先引用捕获所有，指定变量单独值捕获。
• 不能重复捕获：比如 [a, &a] 是语法错误。

三、关键字：mutable 修饰符

核心作用

mutable 关键字的唯一作用：解除「值捕获」的「只读限制」，允许在 lambda 内部修改「值捕获的变量副本」。

注意：只对「值捕获」生效，引用捕获本身就可以修改，加不加 mutable 都一样。

完整示例

int a = 10;
// 1. 无 mutable，值捕获 a → 只读，修改报错
auto func1 = [a]() {
    // a++; 编译报错
    cout << "func1 a = " << a << endl;
};

// 2. 有 mutable，值捕获 a → 可修改副本
auto func2 = [a]() mutable {
    a++; // 正常执行！修改的是「副本」，不是原变量
    cout << "func2 a = " << a << endl; // 输出：11
};
func1(); // 输出：10
func2(); // 输出：11
cout << "外部原变量 a = " << a << endl; // 输出：10 ✔ 原变量没变！

关键结论：mutable 只是让「值捕获的副本」可写，永远不会修改外部的原变量。

四、返回值的写法

1. 自动推导返回值（推荐）

只要 lambda 的函数体中，所有 return 语句的返回值类型一致，编译器会自动推导，可直接省略 -> 返回值类型。

auto add1 = []() { return 10 + 20; };
cout << add1() << endl; // 输出：30

auto add2 = [](int x, int y) { return x + y; };
cout << add2(5, 6) << endl; // 输出：11

auto getStr = []() { return string("hello lambda"); };
cout << getStr() << endl;

2. 显式指定返回值

只有一种情况必须显式指定：函数体中有多个 return 语句，且返回值类型不同。

auto calc = [](int x, bool flag) -> double {
    if (flag) {
        return x; // int → 自动转 double
    } else {
        return 3.14 * x; // double
    }
};
cout << calc(2, true) << endl; // 输出：2.0
cout << calc(2, false) << endl; // 输出：6.28

五、Lambda 的调用方式

1. 定义后立即调用

适合「逻辑简单、只需要执行一次」的场景。

int a = 10, b = 20;
([&a, &b]() {
    a++; b++;
    cout << a << "," << b << endl;
})(); // 输出：11,21

2. 赋值给 auto 变量，后续复用

Lambda 的类型是编译器自动生成的匿名类型，必须用 auto 关键字接收。

auto add = [](int x, int y) { return x + y; };
cout << add(1, 2) << endl; // 第一次调用：3
cout << add(10, 20) << endl; // 第二次调用：30

六、Lambda 的核心特点

1. 本质是「匿名函数对象（仿函数）」：lambda 不是函数，而是编译器自动生成的一个无名的类，重载了 () 运算符。
2. 捕获列表只在「定义时」生效：值捕获在定义时拷贝，引用捕获在定义时绑定地址。
3. 无状态 lambda 可隐式转为函数指针：如果捕获列表为空 []，可以直接赋值给对应签名的函数指针。
4. 生命周期独立：lambda 对象的生命周期和普通变量一致。
5. 极致简洁，无额外开销：编译后会被优化成普通的函数对象代码，没有任何运行时额外开销。

七、经典使用场景

场景 1：配合 STL 算法

STL 的很多算法都支持传入谓词，用 lambda 替代手写的仿函数。

#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;

int main() {
    vector<int> vec = {3, 1, 4, 1, 5, 9, 2, 6};

    // 1. sort 排序：按「降序」排列
    sort(vec.begin(), vec.end(), [](int a, int b) { return a > b; });
    for (auto x : vec) cout << x << " ";
    cout << endl;

    // 2. for_each 遍历：对每个元素做处理
    for_each(vec.begin(), vec.end(), [](int& x) { x *= 2; });
    for (auto x : vec) cout << x << " ";
    cout << endl;

    // 3. find_if 查找：找第一个大于 10 的元素
    auto it = find_if(vec.begin(), vec.end(), [](int x) { return x > 10; });
    if (it != vec.end()) cout << "找到：" << *it << endl;

    return 0;
}

场景 2：作为回调函数

回调函数需要传递一段逻辑，用 lambda 可以就地封装逻辑。

void setTimer(int ms, auto callback) {
    cout << "定时器启动，" << ms << "ms 后执行回调..." << endl;
    callback();
}

int main() {
    int count = 0;
    setTimer(1000, [&count]() {
        count++;
        cout << "回调执行，count=" << count << endl;
    });
    return 0;
}

场景 3：封装小段逻辑

如果有一段逻辑需要多次执行，但又不值得单独写一个函数，用 lambda 封装。

int main() {
    int a = 10, b = 20, c = 30;
    auto print = [&]() {
        cout << "a=" << a << ", b=" << b << ", c=" << c << endl;
    };
    a++;
    print();
    b += 5;
    print();
    c *= 2;
    print();
    return 0;
}

八、补充：C++14 对 Lambda 的增强

1. 支持「泛型 lambda」（参数列表用 auto）

lambda 的参数可以用 auto 声明，编译器会自动推导参数类型。

auto add = [](auto x, auto y) { return x + y; };
cout << add(1, 2) << endl; // 3
cout << add(1.5, 2.5) << endl; // 4.0
cout << add(string("hello"), string(" lambda")) << endl;

2. 支持「初始化捕获」

可以在捕获列表中直接定义变量，同时初始化。

auto func = [n = 10]() {
    cout << n << endl; // 输出：10
};
func();

总结

1. Lambda 本质：匿名函数对象（仿函数），C++11 及以上支持，无运行时开销。
2. 核心语法：[捕获] (参数) mutable noexcept -> 返回值 { 逻辑 };，[]、()、{} 必填。
3. 捕获列表：[] 空捕获；[a,b] 单个值捕获；[=] 全部值捕获；[&a,&b] 单个引用捕获；[&] 全部引用捕获；[=,&a]/[&,b] 混合捕获。
4. mutable：解除值捕获的只读限制，只改副本，不改原变量。
5. 返回值：默认自动推导，多类型 return 时显式指定。
6. 调用方式：立即调用 [](){}() 或 赋值给 auto 后复用 auto f=[](){};f();。
7. 核心优势：就地封装逻辑、简化代码、适配 STL 算法，是 C++ 开发必备技能。