【C++11】Lambda表达式
前言
上文我们学习了C++11新语法，可变参数模板以及用可变参数模板作为形参的emplace接口。【C++11】可变参数模板-CSDN博客
本文我们来学习C++11下一个新语法，Lambda表达式。
1.Lambda表达式语法
Lambda表达式本质是一个匿名函数对象，与普通函数不同，它可以定义在函数内部。
Lambda表达式在语法使用层是没有类型可言的，所以我们一般用auto或者模板定义的对象去接收Lambda对象。
Lambda表达式的格式：
[capture-list] (parameters)-> return type { function boby }[capture-list]：捕捉列表。该列表出现在Lambda表达式的最前面，编译器正式通过 [] 来判断我们所写的代码是否为Lambda表达式。捕捉列表可以捕捉变量供给Lambda表达式使用。捕捉的变量具体分为两类：值捕捉，引用捕捉。捕捉列表不能省略，即使没有捕捉的变量也不能。
(parameters)：参数列表。与普通函数的参数列表功能类似，如果不需要传参，可以连同（）一起省略。
->return type：返回值类型。与普通函数的返回值类型一样，当没有返回值时可省略。但是值得注意的是，一般情况下也会省略，直接让编译器自动推导返回值类型。
{function boby}：函数体。与普通函数的函数体类似。不可省略。
以下是简单Lambda表达式样例：
#include
using namespace std;
//简单Lambda表达式样例
int main()
{
//样例1
auto add = [](int x, int y) ->int { return x + y; };
cout << add(1, 2)< 2.捕捉列表
Lambda表达式默认情况下只能使用参数列表和函数体里的变量，如果要使用Lambda表达式作用域外的变量，就必须要捕捉后才能使用。捕捉分为值捕捉和引用捕捉。
值捕捉，其被捕捉的变量是默认被const修饰的，不能对其进行修改。但在参数列表后面加上关键字mutable可以取消掉其const属性，也就可以修改了。但是仍然是传捕捉，内部的修改不会影响到外部（注：mutable不常用了解即可）。
引用捕捉，其被捕捉的值可以被修改，但内部的修改会影响外部，使其外部变量一起被修改。
第一种捕捉方式：显示捕捉。显示的写出值捕捉/引用捕捉，捕捉多个变量要用逗号分隔。如图，x是值捕捉，y是引用捕捉，y可以被修改且外部也会被影响。
//显示捕捉
int main()
{
int x = 1;
int y = 2;
auto add = [x,&y](int z)
{
y++;
return x + y + z;
};
cout << add(3)<第二种捕捉方式：隐式捕捉。 在捕捉列表中写一个 = 代表将全部的外部变量通过值捕捉的方式进行捕捉， 在捕捉列表中写一个 & 代表将全部的外部变量通过引用捕捉的方式进行捕捉。
补充：其实编译器不会真正的将全部变量捕捉过来，而是看我们的表达式需要使用那些才去捕捉那些
//隐式捕捉
int main()
{
int x = 1;
int y = 2;
int z = 3;
auto add = [=]()
{
return x + y + z;
};
cout << "隐式值捕捉：" << add() << endl;
auto add1 = [&]()
{
x++;
y++;
z++;
return x + y + z;
};
cout << "隐式引用捕捉：" << add1()<第三种捕捉方式：混合捕捉。[&，x]表示x值捕捉，其他变量全为引用捕捉。[=，&x]表示x引用捕捉，其他为值捕捉。 使用混合捕捉=/&必须写在前面。
//混合捕捉
int main()
{
int x = 1;
int y = 2;
int z = 3;
auto add = [=,&z]()
{
z++;
return x + y + z;
};
cout << add() << endl;
cout << "z:" << z << endl;
auto add1 = [&,z]()
{
x++;
y++;
return x + y + z;
};
cout << add1() << endl;
cout << "x:" << x << " " << "y:" << y ;
}捕捉列表只能捕捉Lambda表达式之前的变量，且不能捕捉全局变量和静态局部变量，也不需要捕捉，可以直接使用。这也就意味着当Lambda表达式在全局域时，捕捉列表必须为空。
3.Lambda表达式使用样例
在学习 Lambda 表达式之前，我们所使用的可调用对象仅有函数指针和仿函数对象。函数指针的类型定义较为繁琐，而仿函数需要定义一个类，相对而言也比较麻烦。使用 Lambda 来定义可调用对象，既简单又便捷。
#include
#include
#include
using namespace std;
struct Goods
{
Goods(string name,double price,int evaluate)
:_name(name)
,_price(price)
,_evaluate(evaluate)
{}
string _name; // 名字
double _price; // 价格
int _evaluate; // 评分
};
//价格升序
struct PriceCompare
{
bool operator()(const Goods& a, const Goods& b)
{
return a._price > b._price;
}
};
int main()
{
vector v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3}, { "菠萝", 1.5, 4 } };
//类似这样的场景，若要实现仿函数对象或者函数指针来支持商品中不同项的比较，相对而言还是比较麻烦的。此时，Lambda 就非常实用了
sort(v.begin(), v.end(), PriceCompare());
//Lambda表达式
sort(v.begin(), v.end(), [](const Goods& a, const Goods& b) {return a._price > b._price;});
} 4.Lambda表达式原理
Lambda的原理和范围for很像，编译转化为底层代码后根本没有范围for这个东西的存在，其底层加上迭代器。同样的Lambda仅仅是语法层面的，其底层是仿函数。也就是说我们在实现一个Lambda表达式，本质其实是实现一个仿函数。
仿函数的类名是编译器按照一点规则生成的（按照uuid规则生成的），这保证了不同的Lambda的类名基本不会重复。Lambda的参数/函数体/返回值类型加上仿函数的参数/函数体/返回值类型。Lambda捕捉列表的本质就是生成仿函数的成员变量，也就是说捕捉列表的变量是仿函数的构造函数的实参，当隐式捕捉时，编译器看需要使用那些变量就传那些变量。
以上就是本文全部内容，大佬点个赞再走吧