C++ Lambda 表达式是 C++11 引入的核心语法糖，本质为匿名函数对象。其标准语法包含捕获列表、参数列表、可变修饰符、异常声明及返回值类型。捕获列表控制外部变量访问，支持空捕获、值捕获、引用捕获及混合捕获。mutable 关键字可解除值捕获的只读限制。返回值支持自动推导或显式指定。Lambda 可通过立即调用或赋值给 auto 变量复用。主要应用于配合 STL 算法、作为回调函数及封装小段逻辑。C++14 进一步支持泛型 lambda 和初始化捕获。该特性无运行时开销，能显著简化代码并提升可读性。
Lambda 表达式是 C++11 及以后非常核心的语法糖，本质是「匿名的函数对象（仿函数）」——没有函数名，但能像函数一样调用，是 C++ 中简化代码、实现就地回调/逻辑封装的最优写法之一。
Lambda 的标准完整语法格式如下，中括号 []、小括号 ()、大括号 {} 是必填核心部分，其余是可选修饰：
[捕获列表](参数列表)mutable noexcept-> 返回值类型 {// 函数体（要执行的逻辑代码）};
[]{};）
noexcept 一致，声明当前 lambda 函数体不会抛出任何异常，编译器可做优化return 语句的类型唯一，就可以直接省略这部分！99% 的场景都能省略。Lambda 的核心优势之一就是「捕获外部变量」，捕获列表就是用来控制外部变量的访问规则，所有写法都在 [] 中，分「基础捕获」和「高级捕获」，下面是开发中 99% 会用到的全部写法，按优先级排序，全部背会即可：
[]// 写法：[]auto func = [](){ cout << "空捕获，不能访问任何外部变量" << endl;};func();
[变量名] 或 [=][a, b]int a = 10, b = 20;
// 值捕获：捕获外部变量 a、b，lambda 内部是变量的「拷贝」
auto func = [a, b](){ cout << "a=" << a << ", b=" << b << endl; // 输出：10 20
// a++; 报错！值捕获的变量默认是「只读」的
};func();
[=]int a = 10, b = 20; string s = "hello lambda";
//[=]：捕获当前作用域的「所有外部变量」，全部按「值拷贝」的方式
auto func = [=](){ cout << a << " " << b << " " << s << endl; // 正常输出
};func();
✅ 核心规则：值捕获的本质是「拷贝」
[&变量名] 或 [&][&a, &b]int a = 10, b = 20;
// 引用捕获：捕获外部变量 a、b，lambda 内部是变量的「引用」
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; // 输出：11 20 hello lambda!
};func(); cout << "外部 s=" << s << endl; // 输出：hello lambda!，原变量被修改
✅ 核心规则：引用捕获的本质是「取别名」
场景：需要捕获多个外部变量，一部分只读（值捕获）、一部分需要修改（引用捕获），这是最常用的写法！
int a = 10, b = 20, c = 30;
// 写法：[=, &a] 含义：所有变量默认「值捕获」，但变量 a 单独「引用捕获」
auto func1 = [=, &a](){ a++; // a 是引用，可修改原变量
cout << a << " " << b << " " << c << endl; // b、c 是值拷贝，只读
};func1(); // 输出：11 20 30
// 写法：[&, b] 含义：所有变量默认「引用捕获」，但变量 b 单独「值捕获」
auto func2 = [& , b](){ a++; c++; // a、c 是引用，可修改
// b++; 报错！b 是值捕获，只读
cout << a << " " << b << " " << c << endl; // 输出：12 20 31
};func2();
✅ 混合捕获规则：
[=, &变量名]：优先值捕获所有，指定变量单独引用捕获；[&, 变量名]：优先引用捕获所有，指定变量单独值捕获；[a, &a] 是语法错误。mutable 修饰符（高频考点）mutable 关键字的唯一作用：解除「值捕获」的「只读限制」，允许在 lambda 内部修改「值捕获的变量副本」。
注意：只对「值捕获」生效，引用捕获本身就可以修改，加不加
mutable都一样。
[捕获列表](参数列表)mutable{ 函数体 };
int a = 10;
// 1. 无 mutable，值捕获 a → 只读，修改报错
auto func1 = [a](){
// a++; 编译报错：error: assignment of read-only variable '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 只是让「值捕获的副本」可写，永远不会修改外部的原变量；Lambda 的返回值处理非常灵活，C++11 标准就支持「返回值自动推导」，这也是 lambda 的便捷性之一。
只要 lambda 的函数体中，所有 return 语句的返回值类型一致，编译器会自动推导返回值类型，此时可以直接省略 -> 返回值类型。
// 无参数，返回 int → 自动推导为 int
auto add1 = [](){ return 10 + 20; };
cout << add1() << endl; // 输出：30
// 有参数，返回 int → 自动推导为 int
auto add2 = [](int x, int y){ return x + y; };
cout << add2(5, 6) << endl; // 输出：11
// 返回字符串 → 自动推导为 string
auto getStr = [](){ return string("hello lambda"); };
cout << getStr() << endl;
只有一种情况必须显式指定返回值：函数体中有多个 return 语句，且返回值类型不同，编译器无法自动推导，必须手动声明。
// 多个 return，类型不同 → 必须显式指定返回值类型为 double
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 表达式定义后，本质是一个「匿名的函数对象」，调用方式和普通函数几乎一致，非常简单，两种核心方式：
适合「逻辑简单、只需要执行一次」的场景，写完直接加 (参数) 即可，不用赋值给变量，极致简洁。
int a = 10, b = 20;
// 定义 lambda 的同时，立即调用，执行逻辑
([&a, &b](){ a++; b++; cout << a << "," << b << endl;})(); // 输出：11,21
Lambda 的类型是编译器自动生成的「匿名类型」，我们无法手动写出这个类型，因此必须用 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 的关键，也是面试常问的考点，记住这 5 点，你就吃透了 lambda 的本质：
lambda 不是函数，而是编译器自动生成的一个无名的类，这个类重载了 () 运算符（仿函数），我们定义的 lambda，本质是这个类的一个临时对象；用 auto 接收后，就是这个类的一个实例对象。
lambda 的「捕获行为」是在定义 lambda 的那一刻完成的，不是在调用的时候！
如果 lambda 的捕获列表为空 []，说明它「不依赖任何外部变量」，是一个「无状态 lambda」，可以直接赋值给对应签名的函数指针，这是 C++11 的特性：
// 函数指针类型：int(*)(int, int)
int (*fp)(int, int) = [](int x, int y){ return x + y; };
cout << fp(3, 4) << endl; // 输出：7
lambda 对象的生命周期和普通变量一致，定义在函数内就是局部对象，定义在全局就是全局对象；值捕获的副本，生命周期和 lambda 对象绑定。
lambda 是编译器的「语法糖」，编译后会被优化成普通的函数对象代码，没有任何运行时额外开销，效率和手写的仿函数/普通函数完全一致。
lambda 的优势是「就地封装逻辑、简化代码」，主要用在以下场景，也是你以后写代码一定会用到的地方，全部是高频场景：
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 排序：按「降序」排列，用 lambda 替代自定义比较函数
sort(vec.begin(), vec.end(), [](int a, int b){ return a > b; });
// 输出：9 6 5 4 3 2 1 1
for(auto x : vec) cout << x << " "; cout << endl;
// 2. for_each 遍历：对每个元素做处理，lambda 就地写逻辑
for_each(vec.begin(), vec.end(), [](int&x){ x *= 2; });
// 输出：18 12 10 8 6 4 2 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; // 输出：找到：18
return 0;
}
回调函数需要传递「一段逻辑」，用 lambda 可以就地封装逻辑，不用单独写一个函数，代码更紧凑：
// 模拟一个定时器函数，接收回调逻辑
void setTimer(int ms, auto callback){
cout << "定时器启动，" << ms << "ms 后执行回调..." << endl;
callback(); // 执行回调逻辑
}
int main(){
int count = 0;
// lambda 作为回调函数，捕获外部变量 count
setTimer(1000, [&count](){ count++; cout << "回调执行，count=" << count << endl; });
return 0;
}
如果有一段逻辑需要多次执行，但又不值得单独写一个函数，用 lambda 封装，代码更清晰，且不用污染全局命名空间：
int main(){
int a = 10, b = 20, c = 30;
// 封装一个打印逻辑的 lambda
auto print = [&](){ cout << "a=" << a << ", b=" << b << ", c=" << c << endl; };
a++; print(); // 输出：a=11, b=20, c=30
b += 5; print(); // 输出：a=11, b=25, c=30
c *= 2; print(); // 输出：a=11, b=25, c=60
return 0;
}
C++14 对 lambda 做了两个非常实用的增强，兼容性很好，现在的项目基本都支持，了解后能进一步提升开发效率：
lambda 的参数可以用 auto 声明，编译器会自动推导参数类型，相当于给 lambda 加了模板，一个 lambda 可以适配多种参数类型：
// 泛型 lambda：参数 x、y 用 auto，支持任意可相加的类型
auto add = [](auto x, auto y){ return x + y; };
cout << add(1, 2) << endl; // int+int → 3
cout << add(1.5, 2.5) << endl; // double+double →4.0
cout << add(string("hello"), string(" lambda")) << endl; // string+string → hello lambda
可以在捕获列表中直接定义变量，同时初始化，相当于在 lambda 内部创建一个局部变量，不需要依赖外部作用域：
// 初始化捕获：定义变量 n 并赋值为 10，捕获这个变量（值捕获）
auto func = [n = 10](){ cout << n << endl; // 输出：10
};func();
[捕获] (参数) mutable noexcept -> 返回值 { 逻辑 };，[]、()、{} 必填；[] 空捕获；[a,b] 单个值捕获；[=] 全部值捕获；[&a,&b] 单个引用捕获；[&] 全部引用捕获；[=,&a]/[&,b] 混合捕获，开发高频；[](){}() 或 赋值给 auto 后复用 auto f=[](){};f();；Lambda 是 C++ 中非常优雅的语法，掌握后你的代码会变得更简洁、更高效。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online