什么是Lanmbda?
简短函数，就地书写。常用于向函数(算法)传递函数参数。
语法
Lambda 表达式，[capture](paras)mutable->return type{statement} 全部语法格式，分如下章节介绍：
- [capture]: 捕获列表。捕获列表，总是出现在 lambda 函数的开始处。事实上[ ]是lambda 的引用符。换句话说，编译器根据引出符判断接下来的代码是否是 lamba 函数。
- (paramers): 参数列表。与普能函数的参数列表一致。如果不需要传递参数，可以连同()一起省略。
- mutable: 默认情况下，lambda 函数总是一个 const 函数，mutable 可以取消其常量性。在使用该修饰符时，参数列表不可以省略（即使参数为空）。
- ->return-type: 返回类型。用于追踪返回类型形式声明函数的返回类型。出于方便，不需要返回值的时候可以连同->一起省略。此外返回类型明确的情况下，也可以省略该部分。编译器可以自行推导。
- {statement}: 函数体。内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量。
格式1——[]{}闭包+函数体
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
auto foo = []{ return 1 +2 ;};
cout<<foo();
cout<<[]{ return 1 +2 ;}()<<endl;
return 0;
}
格式2——[](){}闭包+参数+函数体
格式3——[]()->{}闭包+参数+返回值+函数体
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
auto foo = [](int x, int y)->int{return x + y;};
cout<<foo(1,2)<<endl;
cout<<[](int x, int y){return x + y;}(1,2)<<endl;
return 0;
}
格式4——[]()mutable->{}闭包+参数+可修改+返回值+函数体
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
int x = 10; int y = 100;
cout<<"main:"<<x<<y<<endl;
auto foo = [=]()mutable{
x = 20;
y = 200;
cout<<"lambda:"<<x<<y<<endl;
};
foo();
cout<<"main:"<<x<<y<<endl;
return 0;
}
———————————————模块说明—————————————————
[]闭包
lambda 函数能够捕获 lambda 函数外的具有自动存储时期的变量。函数体与这些变
量的集合合起来叫闭包。闭包的概念在 lambda 中通过[]来体现出来。
- [] 不截取任何变量。[bar] 仅对外部变量 bar 值传递在函数体中使用。
- [&bar] 仅对外部变量 bar 引用传递在函数体中使用。
- [x, &y] 仅 x 按值传递，y 按引用传递在函数体中使用。。
- [&} 截取外部作用域中所有变量，并作为引用传递在函数体中使用。
- [=] 截取外部作用域中所有变量，并按值传递在函数体中使用。
- [=, &foo] 截取外部作用域中所有变量，并值传递在函数体中使用，但是对 foo变量使用引用传递。
- [&, =foo] 截取外部作用域中所有变量，在函数体中作引用传递使用，但是对foo 变量作值传递。
上述，中涉及到值传递要发生拷贝行为，而引用传递则不会发生拷贝行为。捕获列表中不允许重复。比如：[=, a] [&,&this]。闭包的本质，初始化 lamda 表达式。
mutable 作用——截取值 还是截取引用？
int main()
{
int i=42;
auto f=[i](){return i+=5;};
i=0;
auto j=f();
cout<<"i="<<i<<endl;
cout<<"j="<<j<<endl;
return 0;
}
运行此函数会提示：error: assignment of read-only variable 'i' auto f=[i](){return i+=5;};
说明{return i+=5;}内的i是受到保护的，无法修改。如果此时将[i](){return i+=5;};改为 [&i](){return i+=5;};就能通过编译，由于传入的是引用，所以i的改变是
执行结果：
i=5;
j=5;
mutable加持！
int main()
{
int i=42;
auto f=[i](){return i+=5;};
i=0;
auto j=f();
cout<<"i="<<i<<endl;
cout<<"j="<<j<<endl;
auto f1=[i](){return i+=5;};
cout<<"k="<<k<<endl;
return 0;
}
如果将表达式改为[i]()mutable{return i+=5;};也可以通过，mutable改变了{return i+=5;} i 的const属性，也可以通过编译。
运行结果：
i=0;
j=47;
K=5;
这说明了什么？
lambda表达式中[i]值的捕获是发生在编译期的！执行时此时 i=42 值早已拷贝传入。所以 i 之后的改变对于表达式运行并无任何影响。
也就是说，当声明时lambda表达式对外部变量（i）以赋值的方式捕获后赋给一个“函数指针”，执行该函数指针时，捕获的变量 (i) 不与外部发生任何关系，无论外部变量如何改变。要想重新“刷新”内部变量，需要重新声明该lambda表达式。
mutable参数只对只[]闭包中捕获的（非引用）值才有作用。对于()传入的参数没有任何影响。