lambda表达式

引言

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

• 先前方法实现复杂例如：

对于自定义类型调用sort()函数，可以通过重载小于运算符；
也可以通过自定义泛型，该方法在调用sort()时需要将泛型填入参数列表。

struct Goods
{
	string _name; // 名字
	double _price; // 价格
	int _evaluate; // 评价
	
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
	//重载<运算
	bool operator<(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};
//自定义泛型
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;
	}
};

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

• lambda表达式写法：

nt main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
	3 }, { "菠萝", 1.5, 4 } };
	
	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._evaluate < g2._evaluate; });
	
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
	return g1._evaluate > g2._evaluate; });
}

通过以上例子可以看出lambda表达式的使用对于代码的简化有很大帮助，以下详细讲解lambda表达式语法。

lambda表达式语法

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

lambda表达式各部分说明：

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

简单理解：

[捕捉列表](参数列表)(mutable可选)->返回值类型(函数体)
//捕捉列表：捕获父作用域中的变量

int a = 10;
int b = 20;
[a, b] {return a + b; };

//参数列表：类似于函数的参数列表
[a, b](int c, int d, int e) {return a + b + c; };

//返回值：类似于函数的返回值
[a, b](int c)->int {return a + b + c; };

//函数体：类似于函数的函数体，可以有多句指令
//mutable：修改捕捉列表中变量的属性为非const,默认为const属性
[a, b](int c)mutable->int {a = 10; b = 200; };

//参数列表和返回值可以省略
[] {};
//返回值类型一般不用写，编译器会自动推导
[a, b] {return a + b; };

//如果有mutable，即使参数列表为空，也需要显示写出来
[a, b]()mutable {return a + b; };


int e = f(10);
//[=]：以值的形式捕捉父作用域中的所有变量
auto f2 = [=]() {return a + b + e; };

//[&]：以引用的形式捕捉父作用域中的所有变量
auto f3 = [&]() {a = 1; b = 1000; };

//[=, &变量x,...]：x引用形式捕捉，其他的以值的形式捕捉
//[&，变量x]：x值形式捕捉，其他的以引用的形式捕捉
//错误的捕捉方式：[=,变量x]，[&, &变量x]
auto f4 = [&, a]() {return a + b; };
auto f5 = [=, &a, &e]() {return a + b + e; };