【C++11】Lambda表达式

前言

上文我们学习了C++11新语法，可变参数模板以及用可变参数模板作为形参的emplace接口。【C++11】可变参数模板-CSDN博客

本文我们来学习C++11下一个新语法，Lambda表达式。

1.Lambda表达式语法

Lambda表达式本质是一个匿名函数对象，与普通函数不同，它可以定义在函数内部。

Lambda表达式在语法使用层是没有类型可言的，所以我们一般用auto或者模板定义的对象去接收Lambda对象。

Lambda表达式的格式：

cpp 复制代码

[capture-list] (parameters)-> return type { function boby }

$capture-list$ ：捕捉列表。该列表出现在Lambda表达式的最前面，编译器正式通过 \[\] 来判断我们所写的代码是否为Lambda表达式。捕捉列表可以捕捉变量供给Lambda表达式使用。捕捉的变量具体分为两类：值捕捉，引用捕捉。捕捉列表不能省略，即使没有捕捉的变量也不能。

(parameters)：参数列表。与普通函数的参数列表功能类似，如果不需要传参，可以连同（）一起省略。

->return type：返回值类型。与普通函数的返回值类型一样，当没有返回值时可省略。但是值得注意的是，一般情况下也会省略，直接让编译器自动推导返回值类型。

{function boby}：函数体。与普通函数的函数体类似。不可省略。

以下是简单Lambda表达式样例：

cpp 复制代码

#include<iostream>
using namespace std;

//简单Lambda表达式样例
int main()
{
	//样例1 
	auto add = [](int x, int y) ->int { return x + y; };
	cout << add(1, 2)<<endl;

	//样例2
	int 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可以被修改且外部也会被影响。

cpp 复制代码

//显示捕捉
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;
}

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

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

cpp 复制代码

//隐式捕捉
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引用捕捉，其他为值捕捉。使用混合捕捉=/&必须写在前面。

cpp 复制代码

//混合捕捉
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 来定义可调用对象，既简单又便捷。

cpp 复制代码

#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捕捉列表的本质就是生成仿函数的成员变量，也就是说捕捉列表的变量是仿函数的构造函数的实参，当隐式捕捉时，编译器看需要使用那些变量就传那些变量。

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