C++11 lambda表达式

作者：@小萌新
专栏：@C++进阶
作者简介：大二学生希望能和大家一起进步！
本篇博客简介：介绍C++11的lambda表达式

lambda表达式

- lambda表达式的概念
- lambda表达式语法
- lambda表达式交换两个数
- lambda表达式的底层原理

lambda表达式的概念

lambda表达式是一个匿名函数他的发明是为了让代码更加的简洁提高代码可读性

下面是代码示例

我们首先来定义一个商品类

class Goods
{
public:
	// 列表初始化
	Goods(string name, double price , int num)
		:_name(name)
		,_price(price)
		,_num(num)
	{}
	string _name; // 商品名
	double _price; // 商品加个
	int _num;  // 数量
};

现在假设我们要按照升序或降序对于这些商品进行排序

如果要对于一个数据集合中的元素进行排序我们可以使用sort函数但是因为这里待排序的是一个结构体所以我们要自行定义一个比较规则
要控制sort函数的比较方式有两种方式一种是重载商品类的（）运算符一种是仿函数
但是由于这里需要比较的方式不是唯一的所以不能重载（）运算符只能使用仿函数

我们这里写出几种仿函数

struct ComparePriceLess
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._price < g2._price;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._price > g2._price;
	}
};
struct CompareNumLess
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._num < g2._num;
	}
};
struct CompareNumGreater
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._num > g2._num;
	}
};

之后我们如果要使用sort函数直接使用仿函数的匿名对象就可以

	vector<Goods> v = { { "苹果", 2.1, 300 }, { "香蕉", 3.3, 100 }, { "橙子", 2.2, 1000 }, { "菠萝", 1.5, 1 } };
	sort(v.begin(), v.end(), ComparePriceLess()); // 按价格升序排序   这里的ComparePriceLess（）其实是一种匿名对象
	sort(v.begin(), v.end(), ComparePriceGreater()); //按价格降序排序
	sort(v.begin(), v.end(), CompareNumLess());      //按数量升序排序
	sort(v.begin(), v.end(), CompareNumGreater());   //按数量降序排序

虽然仿函数确实能够解决这里的问题但是它具有以下问题

在一般的类中成员变量都是私有的所以说如果我们想使用仿函数进行成员变量之间的比较要声明友元函数（这里为了方便就没有将成员变量设置私有）
仿函数的命名要是不具有可读性我们就很难理解是按照什么比较的如果这个时候仿函数还距离使用比较远的话我们就很难弄清楚这个仿函数有什么作用

关于第二点问题的解决我们这里提出一种新的解决方案 lambda表达式

lambda表达式语法

lambda表达式的书写格式如下

     [capture-list](parameters)mutable->return-type{statement}

lambda表达式的各部分说明

捕捉列表

  [capture-list]

该列表总是出现在lambda函数的最前面它的作用跟main函数类似编译器根据它的位置来判断下面的代码是否为lamdba函数捕捉列表能够捕捉上下文中的变量供lambda函数使用

参数列表

  (parameters)

与普通函数的参数列表使用方式一致如果没有参数需要传递可以连同小括号一起省略()

mutable

  mutable

默认情况下 lambda函数总是一个const函数 mutable可以取消其常量性使用该修饰符时参数列表不可省略（即使参数为空)

返回值类型

  ->return-type

用追踪返回类型形式声明函数的返回值类型没有返回值时此部分可以省略
返回值类型明确情况下也可省略由编译器对返回类型进行推导

函数体

   {statement}

函数体内就是要写函数的主题除了可以使用其参数外还可以使用所有捕获到的变量

lambda函数的参数列表和返回值类型都是可选部分但捕捉列表和函数体是不可省略的因此最简单的lambda函数如下：

int main()
{
	[]{}; //最简单的lambda表达式
	return 0;
}

捕获列表说明

捕获列表描述了上下文中哪些数据可以被lambda函数使用以及使用的方式是传值还是传引用

[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量（成员函数包括this指针）
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量（成员函数包括this指针）
[this]：表示值传递方式捕捉当前的this指针

这里对于捕捉列表的一些名词概念予以说明

父作用域指的是包含lambda函数的语句块
语法上捕捉列表可由多个捕捉项组成并以逗号分割比如[=, &a, &b]
捕捉列表不允许变量重复传递否则会导致编译错误比如[=, a]重复传递了变量a
在块作用域以外的lambda函数捕捉列表必须为空即全局lambda函数的捕捉列表必须为空
在块作用域中的lambda函数仅能捕捉父作用域中的局部变量捕捉任何非此作用域或者非局部变量都会导致编译报错
lambda表达式之间不能相互赋值即使看起来类型相同

lambda表达式交换两个数

标准写法

	int a = 10;
	int b = 20;

	auto swap = [](int& x, int& y)->void
	{
		int z = x;
		x = y;
		y = z;
	};
	swap(a, b);

因为lambda表达式是一种匿名函数所以无法直接调用如果想要调用我们可以借助auto关键字将其赋值给一个变量用该变量来实现功能
lambda表达式的函数体在格式上并不是必须写成一行如果函数体太长可以进行换行但换行后不要忘了函数体最后还有一个分号

利用捕获列表进行捕捉

以引用的方式捕捉所有父作用域中的变量省略参数列表和返回值类型比如：

	int a = 10;
	int b = 20;
	auto swap = [&a, &b] // (使用 & 捕获所有参数的引用也可以)
	{
		int z = a;
		a = b;
		b = z;
	};
	swap(); // 我们这里还必须要调用以下这个函数才会使用

传值捕捉

因为我们的lambda函数默认是具有常属性的它不会修改内部对象的值

所以说如果我们使用值传参的话编译器是会报错的像下面这样子

在这里插入图片描述

所以说我们要先使用mutable关键字省略其常属性但是省略了这个属性之后参数列表就不能省略了

	int a = 10;
	int b = 20;
	auto swap = [=]()mutable // (使用 & 捕获所有参数的引用也可以)
	{
		int z = a;
		a = b;
		b = z;
	};
	swap(); // 我们这里还必须要调用以下这个函数才会使用

但是传值传递本质上是对于原始数据的一份临时拷贝它的修改并不会改变原始的数据所以说调用了swap函数也不会发生什么

lambda表达式的底层原理

lambda表达式的底层原理

实际编译器在底层对于lambda表达式的处理方式完全就是按照函数对象的方式处理的函数对象就是我们平常所说的仿函数就是在类中对()运算符进行了重载的类对象

我们下面实现一个对象对于其（）运算符进行重载

之后再编写一个lambda表达式使用函数的方式来调用之

代码如下

class Add
{
public:
	Add(int base)
		:_base(base)
	{}
	int operator()(int num)
	{
		return _base + num;
	}
private:
	int _base;
};
int main()
{
	int base = 1;

	//函数对象
	Add add1(base);
	add1(1000);

	//lambda表达式
	auto add2 = [base](int num)->int
	{
		return base + num;
	};
	add2(1000);
	return 0;
}

我们这里实现了一个add函数它有一个_base的私有成员变量并且我们重载了它的（）运算符

另外我们还实现了一个lambda表达式为了更加深入的了解底层我们调试之后进入反汇编看看汇编代码式什么样子的

在这里插入图片描述

我们可以看到在创建add1的时候使用Add类的构造对象
在再使用时会调用operator（）操作符

在这里插入图片描述

我们可以看到在创建add2的时候使用‘main’类构造对象
而在使用时会调用operator（）操作符

这里的本质原因是因为为lambda表达式在底层被转换成了仿函数

当我们定义一个lambda表达式后编译器会自动生成一个类在该类中对()运算符进行重载实际lambda函数体的实现就是这个仿函数的operator()的实现
在调用lambda表达式时参数列表和捕获列表的参数最终都传递给了仿函数的operator()

lambda表达式之间不能相互赋值

lambda表达式之间是不能相互赋值的就算它们的语法层面一模一样

原因如下

因为lambda表达式在底层的处理方式和仿函数一样在创建的时候它会被定义为一个类类名叫做 <lambda_uuid>
类名中的uuid叫做唯一标识码（Universally Unique Identifier）简单来说uuid就是通过算法生成一串在当前程序中唯一的不会重复的字符串
lambda表达式底层的类名包含uuid 所以说每个类都是独一无二的

我们这里可以用下面的一段代码和其运行结果证明之

int main()
{
	int a = 10, b = 20;
	auto Swap1 = [](int& x, int& y)->void
	{
		int tmp = x;
		x = y;
		y = tmp;
	};
	auto Swap2 = [](int& x, int& y)->void
	{
		int tmp = x;
		x = y;
		y = tmp;
	};
	cout << typeid(Swap1).name() << endl; 
	cout << typeid(Swap2).name() << endl; 
	return 0;
}