引言
C++要走向现代语言，如果不支持lambda表达式，你很难认为这门语言和现代有什么关系。幸好，从C++11标准起，它就实现了对lambda表达式的支持。
那么，什么是lambda表达式呢？
lambda表达式是匿名函数，就是说不用定义函数名，函数实现可以直接嵌入在业务逻辑代码中。诸如python、java、C#等语言，都将其作为基础特性。
其优点是提高了代码的可读性，对于一些无需重用的方法特别适合。例如在容器的迭代中实现特定的查询逻辑。
语法与示例
C++11标准中，对于lambada表达式的定义如下：
[captures] (params) specifiers exception -> ret {body}
- [captures] —— 捕获列表，它用于捕获当前函数作用域的零个或多个变量，变量之间用逗号分隔。
- {params} —— 可选参数列表，其语法与普通函数参数列表一致。如果不需要参数，则可以忽略此项。
- specifiers —— 可选限定符，可选值为
mutable。其意义是可以在函数体内修改按值捕获的变量。 - exception —— 可选异常说明符，可以使用
noexcept来指明lambda是否会抛出异常。 - ret —— 可选返回值类型，lambda使用返回类型后置的语法来表示返回类型。如果没有返回值 ，则可忽略此部分。如果不指定返回类型，则编译器会根据代码实现为函数推导一个返回类型。
- {body} —— 表达式的函数体，此部分与实现普通函数体一致。
从上面的定义可以看到，lambda表达式的语法多少有些与我们以往的认知不太一样。所以，我们直接上代码来体会吧。
#include <iostream>
int main() {
int x = 10;
auto foo = [x](int y)->int { return x + y; };
std::cout << foo(7) << std::endl;
}
各位不要手懒，务必打开IDE将这段代码运行一下，看看结果。然后再尝试修改一下参数类型，或者返回类型。
增加mutable之后，对x变量进行修改，看看会发生什么？
int main() {
int x = 10;
auto foo = [x](int y) mutable ->int { x++; return x + y; };
std::cout << foo(7) << std::endl;
std::cout << foo(7) << std::endl;
std::cout << foo(7) << std::endl;
}
而一个最简形式的lambda表达式，可以是 auto foo = [] { return 0; };。
所以大家以后看到类似语法，可不要大惊小怪了，还以为这是什么另类的数组访问方式，或者琢磨->这个指针指向了个什么东西。
捕获列表
毫无疑问，lambda表达式中，最反直觉的就是捕获列表的定义。毕竟在我们的认知里，中括号是用来定义数组并访问数组元素的。
而且捕获列表的诸多特性，也是面试中挖坑的好地方。我们先从作用域开始说起。
关于lambda表达式的作用域，有四个重点：
- 第一，捕获列表的变量有两个作用域，一是lambda定义的函数作用域，二是表达式函数体所在代码的作用域；
- 第二，在表达式函数体内，默认情况下，被捕获变量是只读属性。如需修改，则要添加
mutable标识； - 第三，在表达式函数体内，修改被捕获变量的值，不影响原始变量的值；
- 第四，被捕获变量必须是非静态局部变量。
好，为了加强印象，我们先从面试挖坑场景开始。请先看第一坑：
int main() {
int x = 10;
auto foo = [x](int y) ->int { x++; return x + y; };
std::cout << foo(8) << std::endl;
}
问：上述代码能通过编译吗？如果不能，是为什么？
答：不能。因为根据规则一和二，在表达式函数体内，x变量是只读，不能被修改。
好，上面的只是开胃菜，诡异的第二坑来了：
int main() {
int x = 10;
auto foo = [x](int y) mutable ->int {
x++;
std::cout << x << std::endl;
return x + y;
};
foo(8);
foo(8);
std::cout << x << std::endl;
}
问：在上述代码执行完后，请说出所有std::cout语句输出什么内容？
答：根据规则三，分别输出11，12，10。
所以大家可以看到，前两次输出是在表达式体内对x值进行修改，x的状态是保留的了。但在函数体外，x变量的值仍然保持不变。千万要记住这个规则，这就是存在两个作用域所得到的结果。
后面我们会讲解其实现原理，这样就可以方便记忆这条规则了。
再来第三坑：
int y = 100;
int main() {
static int x = 10;
auto foo = [x, y](int z) ->int { return x + y + z; };
std::cout << foo(8) << std::endl;
}
问：上述代码有什么问题，应该如何调整？
答：根据作用域规则四，x与y都不能作为lambda表达式的捕获列表变量。在表达式函数体内可以直接使用静态或者全局变量，所以只要修改为auto foo = [](int z) ->int { return x + y + z; };即可。
虽然上面这段代码放在gcc编译器下不会报错，只是出警告：capture of variable ‘x’ with non-automatic storage duration。但编译器实际上是作了一次选择，即认为你的意图是作为全局或静态变量来使用。可如果你只是手误或者忘了要调整代码，那就会出现预料之外的运行结果。
实际上，笔者所在公司就严格要求不能出现编译警告，这对于防止运行期出现偏差是非常重要的。
捕获引用
上一节我们所讲的，都是捕获值的用法。那么想将变量作为引用传递进lambda表达式，是否可以呢？
答案是肯定的，示例如下：
int main() {
int x = 10;
int y = 11;
auto foo = [&x, &y](int z) mutable ->int {
x++;
y++;
return x + y + z;
};
std::cout << foo(8) << std::endl;
std::cout << x << std::endl;
std::cout << y << std::endl;
}
可以看到，捕获引用就是在变量前加上&符号即可。切记不要与取地址相混淆。被引用变量在函数体内修改，也会影响函数体外同名变量的值，这一点与我们以往的认知相同。
至于上述代码结果，请各位先在脑海里执行一遍，然后上机验证。
特殊用法
捕获列表支持三种特殊情况，下面分别说明：
- [this] —— 捕获this指针，可以在类内的lambda表达式函数体内使用，以访问成员变量和方法；
- [=] —— 捕获当前作用域内全部变量的值，包括this。当变量较多时，可使用此符号；
- [&] —— 捕获当前作用域内所有变量的引用，包括this。
先看[this]的示例：
class CaptureOne {
public:
void test() {
auto foo = [this] { std::cout << x << std::endl; };
foo();
}
private:
int x = 100;
};
int main() {
CaptureOne one;
one.test();
}
建议大家在上面这个例子里继续扩展，例如增加一个类方法，看看在表达式函数中如何调用，以及执行结果是什么。
再看[=]的示例：
int main() {
int x = 10;
int y = 11;
int z = 12;
auto foo = [=]() mutable ->int {
x++;
y++;
return x + y + z;
};
std::cout << foo() << std::endl;
std::cout << x << std::endl;
std::cout << y << std::endl;
}
可以看到，这的确是方便了代码书写。如果表达式函数体内的变量增加或减少，都不必再费心思去调整捕获列表了。
另外，不知道大家还注意到一个细节没有，就是当参数列表为空时，如果存在mutable标识，则()是不能省略的。
最后，[&]还是烦请各位自己去实践并体验。
实现原理
C++多年老手，在上手lambda表达式的时候，应该会马上在脑海里跟函数对象关联起来。
我们先从定义一个函数类开始说起。所谓函数类，就是定义一个类，然后重载operator ()。这样可以将类对象作为函数一样来调用。
示例如下：
class FuncOne {
public:
FuncOne(int x, int y) : valx(x), valy(y){}
int operator () () {
return valx + valy;
}
private:
int valx;
int valy;
};
int main() {
FuncOne one(10, 20);
std::cout << one() << std::endl;
}
上述代码就是函数类的定义与函数对象的使用方法。而C++11标准中的lambda表达式，其实就是在编译器在编译期生成一个闭包类（可以理解为类似于FuncOne的类），然后在运行时由这个闭包类生成一个对象，称之为闭包。
而闭包就是一个匿名的函数对象，它包含了定义时作用域的上下文。这样我们就会发现lambda表达式，其实就是C++11给我们提供的一个语法糖。
现在再回头去理解捕获列表的四条原则，是否有恍然大悟之感？理解了原理，对于原则就不用死记硬背了，祝各位面试好运！
应用
当然，我们不能满足于只过面试关，还应当在工作中用好它才行。做C++开发的，用好STL是基本功，而lambda表达式与STL相结合，可以简化代码，发挥出强大的威力来。
先看一个需求：我们要在一组vector列表中，打印可以整除4的数。
示例代码：
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
std::vector<int> num_list = {1, 3, 9, 10, 12, 17, 18};
std::cout << *std::find_if(num_list.cbegin(), num_list.cend(),
[](int i) { return (i % 4) == 0;}) << std::endl;
}
大家可以看到，如果是在以前，要实现这个功能，需要额外写多少代码。
也希望各位能从这个简单示例开始，回头去梳理自己以前写的代码，可以怎样优化结构并提高效率。并且在将来的开发过程中，不断修炼功夫，成为C++大咖！
