【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<iostream>
using namespace std;//简单Lambda表达式样例
int main()
{//样例1 auto add = [](int x, int y) ->int { return x + y; };cout << add(1, 2)<<endl;//样例2int a = 1;int b = 2;auto swap = [](int& x, int& y){int tmep = x;x = y;y = tmep;};swap(a, b);cout<<a<<' '<<b<<endl;
}

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)<<endl;cout << "y:" << y << endl;
}

        第二种捕捉方式：隐式捕捉。 在捕捉列表中写一个 = 代表将全部的外部变量通过值捕捉的方式进行捕捉，  在捕捉列表中写一个 & 代表将全部的外部变量通过引用捕捉的方式进行捕捉。

        补充：其实编译器不会真正的将全部变量捕捉过来，而是看我们的表达式需要使用那些才去捕捉那些

//隐式捕捉
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()<<endl;cout << "x:" << x <<" " << "y:" << y << " " << "z:" << z;
}

        第三种捕捉方式：混合捕捉。[&，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<iostream>
#include<vector>
#include<algorithm>
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<Goods> 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捕捉列表的本质就是生成仿函数的成员变量，也就是说捕捉列表的变量是仿函数的构造函数的实参，当隐式捕捉时，编译器看需要使用那些变量就传那些变量。

以上就是本文全部内容，大佬点个赞再走吧