C++11之lambda表达式

最新推荐文章于 2024-06-15 10:30:23 发布

Hoshino373

最新推荐文章于 2024-06-15 10:30:23 发布

阅读量414

点赞数

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/m0_59938453/article/details/128580911

版权

C++ 专栏收录该内容

20 篇文章 11 订阅

订阅专栏

文章目录

一、引入原因
二、lambda 表达式的语法
- 1. lambda 表达式各部分说明
- 2.捕捉列表说明
三、lambda 表达式的本质

一、引入原因

如果待排序元素为自定义类型，需要用户定义排序时的比较规则。
比如：

struct Goods
{
	string _name;     // 名字
	double _price;    // 价格
	int _evaluation;  // 评价

	Goods(const char* name, double price, int evaluation)
		:_name(name)
		, _price(price)
		, _evaluation(evaluation)
	{}
};

struct ComparePriceLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};

struct ComparePriceGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price > gr._price;
	}
};

struct CompareEvaluationLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._evaluation < gr._evaluation;
	}
};

struct CompareEvaluationGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._evaluation > gr._evaluation;
	}
};

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 },{ "香蕉", 3, 4 },{ "橙子", 2.2, 3 },{ "菠萝", 1.5, 4 } };
	
	// 仿函数作为可调用对象
	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());
	sort(v.begin(), v.end(), CompareEvaluationLess());
	sort(v.begin(), v.end(), CompareEvaluationGreater());

	return 0;
}

随着 C++ 语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个 algorithm 算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是类的命名，这些都给编程者带来了极大的不便。因此，在 C++11 语法中出现了 lambda 表达式。

对上面的例子，使用 C++11 中的 lambda 表达式替换掉仿函数之后：

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 },{ "香蕉", 3, 4 },{ "橙子", 2.2, 3 },{ "菠萝", 1.5, 4 } };

	/*auto ComparePriceLess = [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; };
	sort(v.begin(), v.end(), ComparePriceLess);*/

	// lambda表达式作为可调用对象
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price > g2._price; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluation < g2._evaluation; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluation > g2._evaluation; });

	return 0;
}

通过上面的代码可以看出，lambda 表达式实际是一个匿名函数。

二、lambda 表达式的语法

lambda表达式书写格式：[capture-list](parameters) mutable ->return-type { statement }

1. lambda 表达式各部分说明

① [capture-list]：捕捉列表，该列表总是出现在 lambda 函数的开始位置，编译器根据 [ ] 来判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下文中的变量供 lambda 函数使用。可以为空，但不能省略。
② (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同 () 一起省略。
③ mutable：传值捕捉的变量在函数体中默认是 const 类型，即不可修改。在添加了 mutable 后，便取消了其常量性，可以对此变量进行修改，但此时修改的仍然是位于 lambda 函数体中的局部变量。使用该修饰符时，参数列表不可省略（即使参数为空）。
④ ->return-type：返回值类型。用追踪返回类型的形式声明函数的返回值类型，没有返回值时此部分可省略。在返回值类型明确的情况下，也可省略，由编译器对返回值类型进行推导。
⑤ { statement }：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。可以为空，但不能省略。

注意：
在 lambda 函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。
因此 C++11 中最简单的 lambda 函数为：[ ] { } ，该 lambda 函数不能做任何事情。

测试代码1：

int main()
{
	// 实现一个两个数相加的lambda表达式
	auto add1 = [](int a, int b)->int {return a + b; };
	// 在返回值类型明确的情况下，也可省略
	//auto add1 = [](int a, int b) {return a + b; };
		
	cout << add1(1, 2) << endl;

	// 若没有参数，则可以省略参数列表
	auto Func1 = [] {cout << "hello world" << endl; };
	Func1();

	return 0;
}

测试代码2：

int main()
{
	int a = 1, b = 2;
	// 传值捕捉的变量在函数体中默认是const类型，即不可修改
	auto swap1 = [a, b](){
		int z = a;
		//a = b;    // 编译报错
		//b = z;    // 编译报错
		cout << a << " " << b << endl;
	};
	swap1();
	cout << a << " " << b << endl;

	// 在添加了mutable后，便取消了传值捕捉的变量的常量性，可以对此变量进行修改
	// 但此时修改的仍然是位于lambda函数体中的局部变量
	auto swap2 = [a, b]()mutable {
		int z = a;
		a = b;
		b = z;
		cout << a << " " << b << endl;
	};
	swap2();  // 由于是传值捕捉，所以无法改变lambda函数外的a,b变量
	cout << a << " " << b << endl;

	return 0;
}

测试代码3：

int main()
{
	int a = 1, b = 2;
	// 传引用传参
	auto swap3 = [](int& x, int& y) {
		int z = x;
		x = y;
		y = z;
	};
	swap3(a, b);  // 可以改变a,b变量
	cout << a << " " << b << endl;

	// 传引用捕捉
	auto swap4 = [&a, &b]() {
		int z = a;
		a = b;
		b = z;
	};
	swap4();     // 可以改变a,b变量
	cout << a << " " << b << endl;

	return 0;
}

通过上述代码可以看出，lambda 表达式其实是一个匿名函数（即没有函数名的函数），该函数无法直接调用，如果想要直接调用，需要将其赋值给一个变量（变量的类型使用 auto 自动推导）。

2.捕捉列表说明

捕捉列表描述了上下文中哪些变量可以被 lambda 函数体使用，以及变量的捕捉方式是传值捕捉还是传引用捕捉。

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

注意：
① 父作用域指包含 lambda 函数的语句块。
② 捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：以传值方式捕捉所有变量，除了 a,b 变量以传引用捕捉。
[&, a, b]：以传引用方式捕捉所有变量，除了 a,b 变量以传值捕捉。
[a, &b]：以传值方式捕捉 a 变量，以传引用方式捕捉 b 变量。
③ 捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：已经以传值方式捕捉了所有变量，传值捕捉 a 重复。
[&, &a]：已经以引用方式捕捉了所有变量，传引用捕捉 a 重复。
④ 不能捕捉带有静态存储持续时间的变量，但可以在函数体中直接访问。
⑤ 在块作用域中的 lambda 函数，仅能捕捉父作用域中的局部变量。

测试代码1：

// 不能捕捉带有静态存储持续时间的变量，但可以在函数体中直接访问
int p = 10;
static int q = 20;

//auto func1 = [p, &q]() {};   // 编译报错
auto func2 = []() {p += 2; q += 5; };

int main()
{
	//auto func3 = [p]() {};   // 编译报错
	auto func4 = []() {++p; ++q; };
	auto func5 = []() {cout << p << " " << q << endl; };
	
	func4();
	func5();
	
	return 0;
}

测试代码2：

// 在块作用域中的 lambda 函数，仅能捕捉父作用域中的局部变量
int main()
{
	int x = 1, y = 2;

	auto func6 = [x, &y]() {
		y = 4;
		cout << x << " " << y << endl;
	};

	func6();

	return 0;
}

其实，捕捉跟传参差不多，若不想传参，可以在捕捉列表进行捕捉。

三、lambda 表达式的本质

通过下面的代码来查看 lambda 表达式的类型：

int main()
{
	int a = 1, b = 2;
	auto swap3 = [](int& x, int& y) {
		int z = x;
		x = y;
		y = z;
	};

	cout << typeid(swap3).name() << endl;  // 打印lambda表达式的类型

	return 0;
}

在 VS2015 下，其运行结果是：
class <lambda_7721a5d10c60e907b096b0ca7c8bb873> ，即 class <lambda_UUID> 的形式。

UUID（即 Universally Unique Identifier，通用唯一识别码）是通过算法生成的唯一字符串，能够保证每次生成的 UUID 都不会重复。

其实，lambda 表达式本质上是仿函数，就像范围 for 本质上是迭代器一样。
我们将通过下面的例子进行说明：

class Rate
{
public:
	Rate(double rate) 
		: _rate(rate)
	{}

	double operator()(double money, int year)
	{
		return money * _rate * year;
	}

private:
	double _rate;
};

int main()
{
	double rate = 0.49;
	
	// 函数对象
	Rate r1(rate);
	r1(10000, 2);  // 调用函数对象

	// lambda表达式
	auto r2 = [=](double money, int year)->double {return money*rate*year; };
	r2(10000, 2);  // 调用lambda

	return 0;
}

在 VS2015 下，观察和对比仿函数与 lambda 表达式的反汇编代码：
lambda 的底层实现，其实是被处理成一个类名为 <lambda_UUID> 的仿函数类。
在调用 lambda 时，会先构造一个 lambda 对象，然后调用 lambda 对象的 operator() 函数。

由于 lambda 表达式在底层实现时会被处理成类名为 <lambda_UUID> 的仿函数类，而且生成的 UUID 能保证不重复。
因此，两个 lambda 表达式，即使实现完全一样，但本质上也是两个不同类型的仿函数类，所以它们之间不能相互赋值。

// lambda表达式之间不能相互赋值
int main()
{
	int x = 5, y = 7;
	
	auto f1 = [x, &y]()->int {y = 2 * x; return x + y; };
	auto f2 = [x, &y]()->int {y = 2 * x; return x + y; };
	
	// 即使实现完全一样，但本质上也是两个不同的仿函数类
	// 类型不同
	cout << typeid(f1).name() << endl;
	cout << typeid(f2).name() << endl;

	// f1 = f2;  // 编译报错
	
	return 0;
}

lambda 表达式允许拷贝构造。

// 允许使用一个lambda表达式拷贝构造一个新的副本
int main()
{
	auto f3 = []() {cout << "hello world" << endl; };
	auto f4(f3);

	// 由于是拷贝构造，所以副本类型跟原类型相同
	cout << typeid(f3).name() << endl;
	cout << typeid(f4).name() << endl;
	
	// 由于lambda表达式删除了operator=函数
	// 所以相同类型的lambda表达式也不能相互赋值
	// f3 = f4;  // 编译报错
	
	return 0;
}