C++ lambda 表达式深剖

目录

    • 传统艺能
    • 概念
    • 语法
    • 捕获方式
      • 相互赋值
    • mutable
    • 底层原理

传统艺能

小编是双非本科大一菜鸟不赘述,欢迎米娜桑来指点江山哦(QQ:1319365055)

非科班转码社区诚邀您入驻
小伙伴们,打码路上一路向北,彼岸之前皆是疾苦
一个人的单打独斗不如一群人的砥砺前行
这是我和梦想合伙人组建的社区,诚邀各位有志之士的加入!!
社区用户好文均加精(“标兵”文章字数2000+加精,“达人”文章字数1500+加精)
直达: 社区链接点我


C++ lambda 表达式深剖_第1张图片

概念

自 C++11 开始,C++ 有三种方式可以创建/传递一个可调用的对象:

函数指针
仿函数
Lambda 表达式

lambda 表达式本质上就是一个匿名函数,它是一个强大的功能,他的使用可以简化代码,而且可以提高代码可读性

这里举一个实例,以一个物品为例:

struct Items
{
	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;
	}
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 300 }, { "香蕉", 3.3, 100 }, { "橙子", 2.2, 1000 }, { "菠萝", 1.5, 1 } };
	sort(v.begin(), v.end(), ComparePriceLess());    //价格升序
	sort(v.begin(), v.end(), ComparePriceGreater()); //价格降序
	sort(v.begin(), v.end(), CompareNumLess());      //数量升序
	sort(v.begin(), v.end(), CompareNumGreater());   //数量降序
	return 0;
}

如你所见,仿函数也顺利解决了以上问题,但是如果定义和使用位置隔的很远就不好观察,这就要求取名的时候通俗易懂,这种情况下就更加推荐使用 lambda 表达式。

比如我这里有一个做加法的仿函数:

class Plus {
 public:
  int operator()(int a, int b) {
    return a + b;
  }   
};

Plus plus; 
std::cout << plus(11, 22) << std::endl;

我们把这个加法仿函数改写成 lambda 表达式就是

auto Plus = [](int a, int b) { return a + b; };

因为 lambda 表达式是一个匿名函数,该函数无法直接调用,这里我们借助 auto 将其赋值给一个变量,此时这个变量就可以像普通函数一样使用

这前后一对比,显而易见两者的优劣就高下立判了

语法

lambda 表达式定义

[ capture-list ] ( params ) mutable(optional) exception(optional) attribute(optional) -> ret(optional) { body } 

当然在书写格式上并不是必须写成一行,如果函数体太长可以进行换行
说明一下各个参数:

capture-list:捕捉列表。上面的例子 auto Plus = [](int a, int b) { return a + b; }; 就没有捕获任何变量
params:和普通函数一样的参数。
mutable:只有这个 Lambda 表达式是 mutable 的才允许修改按值捕获的参数。
-> ret:返回值类型,可省略,编译器可以通过 return 语句自动推导
body:具体函数

没说明的就暂时不必理解,其中 除了捕获列表, L a m b d a 表达式的其它地方其实和普通的函数基本一样 \color{red} {除了捕获列表,Lambda 表达式的其它地方其实和普通的函数基本一样} 除了捕获列表,Lambda表达式的其它地方其实和普通的函数基本一样lambda 参数列表和返回值类型都是可有可无的,但捕捉列表和函数体是不可省略的,因此最简单的lambda函数如下:

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

捕获方式

Lambda 表达式最基本的两种捕获方式是:按值捕获按引用捕获

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

[var]:值传递捕捉变量var
[=]:值传递捕获所有父作用域中的变量(成员函数包括this指针)
[&var]:引用传递捕捉变量var
[&]:引用传递捕捉所有父作用域中的变量(成员函数包括this指针)
[this]:值传递捕捉当前的this指针

实际当我们以 [&](引用传递全捕获) 或 [=] (值传递全捕获)的方式捕获变量时,编译器也不一定会把父作用域中所有的变量捕获进来,编译器可能只会对 lambda 表达式中用到的变量进行捕获,实际要看编译器的具体实现

父作用域就是包含 lambda 表达式的语句块,语法上捕捉列表可由多个逗号分割的捕捉项组成,比如KaTeX parse error: Expected '}', got '&' at position 18: …olor{red} {[=, &̲a, &b]} ,我们需要清楚 3 点:

  1. 捕捉列表不允许重复传递,否则会导致编译错误,比如 [ = , a ] \color{red} {[=, a]} [=,a]重复传递了变量 a
  2. lambda表达式之间不能相互赋值,即使看起来类型相同
  3. 在块作用域以外的 lambda 表达式捕捉列表必须为空!即全局lambda函数的捕捉列表必须为空,且在块作用域中的 lambda 表达式仅能捕捉父作用域中的局部变量,除此以外的都会导致编译报错。

相互赋值

lambda表达式之间不能相互赋值,就算是两个一模一样的也不行,这不邪门儿了嘛,为啥呢?

因为 lambda 表达式底层处理方式和仿函数是一样的(本文后面的底层原理部分有细谈),在VS下 lambda 表达式会被处理为函数对象,该函数对象对应的类名叫做

类名中的uuid叫做通用唯一识别码,简单来说就是通过算法生成的一串字符串,它具有随机性和不重复性,保证在当前程序中每次生成不同的 uuid,因为 lambda 表达式底层的类名包含 uuid,这就保证了每个 lambda 表达式底层类名都是唯一的!

我们可以通过 t y p e i d ( 变量名 ) . n a m e ( ) \color{red} { typeid(变量名).name() } typeid(变量名).name()的方式来获取lambda表达式的类型来验证上述结论:

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; //class 
	cout << typeid(Swap2).name() << endl; //class 
	return 0;
}

如你所见,就算是一模一样的 lambda 表达式,它们的类型也是不同的

mutable

在实际使用中,比如实现一个交换函数,我们用 lambda 表达式实现:

int main()
{
	int a = 1, b = 2;
	auto Swap = [a, b]()
	{
		int tem = a;
		a = b;
		b = tem;
	};
	Swap(); 
	return 0;
}

这里一眼就是传值捕获,但是真的可以吗?答案是 No,他的编译不会通过,因为传值捕获到的变量默认是不可修改的(const):

//值捕获的类型是 const 类型
int i = 100;
auto func = [i]() {
    i = 200;  // 编译错误:assignment of read-only variable ‘i’
}; 

如果要取消其常量属性,就需要在 lambda 表达式中加上 mutable 像这样:

auto Swap = [a, b]()mutable
	{
		int tem = a;
		a = b;
		b = tem;
	};

但由于是传值捕捉,lambda 表达式中对局部变量的修改不会影响本身的变量,与函数的传值传参是一个道理,因此这种方法无法完成交换功能。

底层原理

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

我们编写了一个 Add 类,然后对 () 运算符进行了重载,因此 Add 类实例化出的 add1 对象就是函数对象,add1 可以像函数一样使用。接着写了一个 lambda 表达式,并借助 auto 将其赋值给 add2 对象,这时 add1 和 add2 都可以像普通函数一样使用

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;
}

我们再通过反汇编对代码进行观察:
C++ lambda 表达式深剖_第2张图片
创建函数对象 add1 时,会调用 Add 类的构造函数,使用 add1 时,会调用 Add 类的 () 运算符重载函数。
C++ lambda 表达式深剖_第3张图片

然后 lambda 表达式这边也是和函数的过程非常类似:在借助 auto 将 lambda 表达式赋值给 add2 对象时,会调用 类的构造函数,在使用add2对象时,会调用类的()运算符重载函数

本质就是因为 l a m b d a 表达式在底层被转换成了仿函数 \color{red} {本质就是因为lambda表达式在底层被转换成了仿函数} 本质就是因为lambda表达式在底层被转换成了仿函数

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

aqa 芭蕾 eqe 亏内,代表着开心代表着快乐,ok 了家人们。

你可能感兴趣的:(C++,lambda,表达式,c++11)