C++11中新增的一种函数对象：lambda表达式

吃不饱的得可可

已于 2024-05-16 09:12:39 修改

阅读量1.1k

点赞数 30

文章标签： c++ 开发语言

于 2024-05-15 23:40:42 首次发布

本文链接：https://blog.csdn.net/2401_84568462/article/details/138922205

版权

在学习lambda表达式之前我们先来看一下函数对象是什么，以及它们之间的关系。

一、函数对象和lambda表达式

函数对象，又称为仿函数，仿函数是可以像函数一样使用的类对象，该类对象重载了operator()运算符。下面我们来写一个函数对象和lambda表达式来简单分析一下：

#include<iostream>
using namespace std;
class K
{
public:
	K(int k = 0)
		:_k(k)
	{}
	double operator()(double a, int b)
	{
		return a * b;
	}

private:
	int _k;
};
int main()
{
	int k = 7;
	K kk(k);//kk是函数对象
	double result1 = kk(1.1, 1);//调用了上面类中的operator()
	cout << result1 << endl;

	auto k1= [=](double a, int b)->double {return a * k * b;};//k1是由lambda表达式创建的
                                                              //匿名函数对象
	double result2 = k1(1.1, 1);//调用operator(),return a*k*b就是operator()函数的里的内容
	cout << result2 << endl;
	return 0;
}

总结：lambda表达式的使用方式与函数对象的使用方式相同,实际在底层编译的时候编译器对于lambda表达式的处理方式，完全是按照函数对象的处理方式处理的。即：如果定义一个了lambda表达式，编译器会自动生成一个类，在该类中重载operator()。

二、lambda表达式的一个应用

在C++98中，我们可以利用std::sort对一个数据集合中的元素进行排序：

#include<iostream>
#include<algorithm>
#include<functional>//std::greater
using namespace std;
int main()
{
	int arr[] = { 8,3,7,2,9,6,7 };
	sort(arr, arr + sizeof(arr) / sizeof(arr[0]));//默认按照升序排序
	for (auto e : arr)
	{
		cout << e << " ";
	}
	cout << endl;
	sort(arr, arr + sizeof(arr) / sizeof(arr[0]), greater<int>());//降序
	for (auto e : arr)
	{
		cout << e << " ";
	}
	return 0;
}

但是如果待排序元素为自定义类型，就需要我们自己定义排序规则了。如下代码：

#include<iostream>
#include<algorithm>
#include<functional>//std::greater
#include<vector>
using namespace std;
struct Users
{
	Users(const char* str, int rank)
		:_name(str)
		, _rank(rank)
	{}
	string _name;  //CSDN用户名
	double _rank; //原力等级
};
struct ComparePriceLess
{
	bool operator()(const Users& u1, const Users& u2)
	{
		return u1._rank < u2._rank;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Users& u1, const Users& u2)
	{
		return u1._rank > u2._rank;
	}
};
int main()
{
	vector<Users> v = { { "凌风", 5}, { "世界", 3}, { "玉珠", 6} };
	sort(v.begin(), v.end(), ComparePriceLess());
	for (auto e : v)
	{
		cout << e._rank << " ";
	}
	cout << endl;
	sort(v.begin(), v.end(), ComparePriceGreater());
	for (auto e : v)
	{
		cout << e._rank << " ";
	}
}

上面是比较类Users中的_rank来排序Users对象的，那就自己写出相应的比较_rank的仿函数。但是如果要根据CSDN用户名来排序Users对象还得自己再写相应的仿函数，那如果要排序的类对象成员变量有很多个的情况下，就难以实现了，基于以上原因，我们来使用lambda表达式来实现，就相对容易一点了。接下来我们来看一下用lambda表达式实现的代码：

int main()
{
	vector<Users> v = { { "凌风", 5}, { "世界", 3}, { "玉珠", 6} };

	sort(v.begin(), v.end(), [](const Users& u1, const Users& u2)->bool{
		return u1._rank < u2._rank; });//升序

	for (auto e : v)
	{
		cout << e._rank << " ";
	}
	cout << endl;

	sort(v.begin(), v.end(), [](const Users& u1, const Users& u2)->bool{
		return u1._rank > u2._rank; });//降序

	for (auto e : v)
	{
		cout << e._rank << " ";
	}
}

如果要通过类对象的其他成员变量来排序对象只需要改动lambda表达式中的函数体部分即可，不用再自己实现相应的仿函数了。

三、lambda表达式的语法

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

}

1. lambda表达式各部分说明

[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来

判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda

函数使用。

(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以

连同()一起省略

mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量

性。使用该修饰符时，参数列表不可省略(即使参数为空)。

->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回

值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推

导。

{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获

到的变量。

int main()
{
	// 最简单的lambda表达式, 该lambda表达式没有任何意义
	[] {};

	// 省略参数列表和返回值类型，返回值类型由编译器推导为int
	int a = 3, b = 4;
	[=] {return a + 3; };

	// 省略了返回值类型，无返回值类型
	auto fun1 = [&](int c) {b = a + c; };
	fun1(10);
	cout << a << " " << b << endl;

	// 各部分都很完善的lambda函数
	auto fun2 = [=, &b](int c)->int {return b += a + c; };
	cout << fun2(10) << endl;
}

2. 捕获列表说明

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

[var]：表示值传递方式捕捉变量var。

[=]：表示值传递方式捕获所有父作用域中的变量(包括this)。

[&var]：表示引用传递捕捉变量var。

[&]：表示引用传递捕捉所有父作用域中的变量(包括this)。

[this]：表示值传递方式捕捉当前 的this指针。

四、写lambda表达式时的一些注意事项

在写lambda表达式的时候要注意以下几点：

1.父作用域指包含 lambda 函数的语句块。

2.语法上捕捉列表可由多个捕捉项组成，并以逗号分割。

比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量

[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量。

3.捕捉列表不允许变量重复传递，否则就会导致编译错误。

比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复。

4. lambda 表达式之间不能相互赋值， 即使看起来类型相同。

五、lambda表达式的其他性质

void (*pf)();//pf为函数指针该指针指向的函数返回值为0，参数列表为空
int main()
{
	auto f1 = [] {cout << "CSDN" << endl; };
	//不可以将
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f2(f1);
	f2();
	// 可以将lambda表达式赋值给相同类型的函数指针
	pf = f2;
	pf();
	return 0;
}