lambda表达式

文章目录：

lambda表达式概念
lambda表达式语法
函数对象与lambda表达式

lambda表达式概念

lambda 表达式是 c++11 中引入的一种匿名函数，它可以在需要函数对象的地方使用，可以用作函数参数或返回值。lambda 表达式可以看作是一种局部定义的函数对象，它通常用于简化代码或实现某些特定的功能。

接下来我们举一个例子来说明为什么需要 lambda 表达式：

商品类 Goods 的定义：

struct Goods
{
	string _name;  // 名字
	double _price; // 价格
	int _count;    // 数量
};

现在，我们需要对若干商品分别按照价格和数量进行升序、降序排序。

想要对一个数据集合中的元素进行排序，可以使用 sort 函数，但是这里的待排序元素是自定义类型，因此需要用户自定义排序的比较规则。控制 sort 函数的比较方式通常有两种方法：1. 对商品类的 () 运算符进行重载； 2. 通过仿函数指定比较方式。

下面使用仿函数的方式来完成上述的排序：

struct Goods
{
	Goods(const char* str, double price, int count)
		:_name(str)
		,_price(price)
		,_count(count)
	{}

	string _name;
	double _price;
	int _count;
};

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 CompareNumLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._count < gr._count;
	}
};

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

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 50 }, { "香蕉", 3, 40 }, { "草莓", 2.2,30 }, { "菠萝", 1.5, 40 },{"芒果",2.5,120} };
	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());
	sort(v.begin(), v.end(), CompareNumLess());      
	sort(v.begin(), v.end(), CompareNumGreater()); 
}

使用仿函数可以解决自定义类型的排序问题，在大型项目中，有可能仿函数的定义位置和使用仿函数的位置可能会相隔很远，所以仿函数的命令必须要通俗易懂，否则会降低代码的可读性和可维护性。

随着 c++ 语法的发展，人们觉得上面的写法太复杂了，每次为了实现一个 algorithm 算法，都需要重新去写一个类，如果每次比较的逻辑不一样，还需要去实现多个类，特别是相同类的命名。因此，c++11 中出现了 lambda 表达式。

使用 lambda 表达式完成上面要求，如下：

struct Goods
{
	Goods(const char* str, double price, int count)
		:_name(str)
		,_price(price)
		,_count(count)
	{}

	string _name;
	double _price;
	int _count;
};

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 50 }, { "香蕉", 3, 40 }, { "草莓", 2.2,30 }, { "菠萝", 1.5, 40 },{"芒果",2.5,120} };
	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._count < g2._count;});
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._count > g2._count;});
}

在这个代码示例中，使用 lambda 表达式作为 sort 函数的第三个参数，可以方便地根据不同的排序标准对 vector 中的 Goods 对象进行排序，而不需要单独定义多个比较函数。这样可以减少代码量和提高代码的可读性，同时节省定义函数的时间和空间开销。

lambda表达式语法

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

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

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

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

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

说明：

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

lambda 表达式使用示例：

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

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

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

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

	// 复制捕捉x
	int x = 5;
	auto add_x = [x](int a) mutable {x *= 2;return a + x;};
	cout << add_x(10) << endl;
	return 0;
}

以下代码演示了 lambda 函数的拷贝构造以及如何将 lambda 表达式赋值给函数指针：

void (*pfunc)();

int main()
{
	auto f1 = [] {cout << "lambda" << endl;};
	auto f2 = [] {cout << "lambda" << endl;};

	// f1 = f2; // 编译失败，提示找不到operator=()
	
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f3(f2);
	f3();

	// 可以将lambda表达式赋值给相同类型的函数指针
	pfunc = f2;
	pfunc();
	return 0;
}

函数对象与lambda表达式

函数对象，又称为仿函数，即可以像函数一样使用的对象，就是在类中重载了 operator() 运算符的对象。

如下所示，分别使用函数对象和 lambda 表达式实现计算利息：

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 monty, int year)->double {return monty * rate * year;};
	r2(10000, 2);
	return 0;
}