C++11 lambda表达式

1.引入及概念

在c++11之前，想要对某种类型进行排序我们可以使用sort函数，不过需要用户定义排序时的比较规则，即仿函数。例如：

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
struct Goods
{
	string _name; // 名字
	double _price; // 价格
	int _evaluate; // 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
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(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());
}

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

int 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表达式是C++11中引入的一项新特性，它允许程序员在代码中定义匿名函数。这些匿名函数可以捕获周围作用域中的变量，并且可以直接在声明它们的地方使用。Lambda表达式的语法简洁，使得编写临时的、内联的函数变得更加方便，尤其是在需要传递给算法或作为回调函数时。

2.语法

Lambda表达式的一般语法结构如下：

[capture-list] (parameters) mutable -> return-type { function-body }

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

例如这是一个完整的lambda表达式以及使用，lambda表达式实际上可以理解为无名函数，类名随机，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量。然后该变量即可表示仿函数。

auto add = [](int a, int b)mutable -> int { return a + b; };
cout << add(3, 5) << endl;

2.1 捕捉列表说明

捕捉列表描述了上下文中那些数据可以被 lambda 使用 ，以及 使用的方式传值还是传引用。捕获列表可以是空的，也可以包含一个或多个变量。常见的捕获方式包括：

• [var]：表示值传递方式捕捉变量var，即修改lambda表达式内的var，不改变外部的var
• [=]：表示值传递方式捕获所有父作用域中的变量(包括this)，即修改lambda表达式内的变量，不改变外部的变量
• [&var]：表示引用传递捕捉变量var
• [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
• [this]：表示值传递方式捕捉当前的this指针

注意：

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

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

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

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

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

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

d. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。

e. lambda 表达式之间不能相互赋值，即使看起来类型相同，实际上lambda 表达式生成的类名是随机的。例如：

void (*PF)();
int main()
{
    // 没有参数时，参数列表（）可以省略，返回值可以自动推导也可以省略
	auto f1 = [] {cout << "hello world" << endl; };
	auto f2 = [] {cout << "HELLO WORLD" << endl; };
    // f1 = f2;   // 编译失败--->提示找不到operator=()
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f3(f2);
	f3();
	// 可以将lambda表达式赋值给相同类型的函数指针
	PF = f2;
	PF();
	return 0;
}

2.2 mutable的使用

在C++11中，Lambda表达式默认情况下创建的是一个常量的函数对象，即Lambda函数总是一个const函数，这意味着Lambda表达式内部不能修改通过值捕获的变量。如果需要在Lambda表达式内部修改这些变量，可以使用mutable关键字来取消其常量性。一旦Lambda表达式被标记为mutable，即使是通过值捕获的变量也可以在Lambda表达式的函数体内被修改。注意如果使用了mutable，就算没有通过参数列表传参，( )也不可以省略。

int main()
{
	int a = 3, b = 5;
	auto add = [a, b]() mutable
	{
		a++;//当为值传递且没有muttable修饰时要修改a报错
		return a + b;
	};
	cout<< add()<<endl;
	cout << a << endl;
	return 0;
}

不过在Lambda表达式内修改a的值不影响外部a的值，程序运行之后可以看到结果a的值并未改变

如果使用了传引用捕获变量，就算没有 mutable也可以修改参数，并且Lambda表达式内修改a的值外部a的值也会改变。

int main()
{
	int a = 3, b = 5;
	auto add = [&a, &b]()
	{
		a++;//当为值传递且没有muttable修饰时要修改a报错
		return a + b;
	};
	cout<< add()<<endl;
	cout << a << endl;
	return 0;
}

3. 函数对象与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.015;
	Rate r1(rate);
	r1(10000, 2);
	// lambda
	auto r2 = [=](double money, int year)->double 
	{
		return money * rate * year;
	};
	r2(10000, 2);
	return 0;
}

从使用方式上来看，函数对象与 lambda 表达式完全一样。函数对象将rate 作为其成员变量，在定义对象时给出初始值即可， lambda 表达式通过捕获列表可以直接将该变量捕获到。

实际在底层编译器对于 lambda 表达式的处理方式，完全就是按照函数对象的方式处理的，即：如

果定义了一个 lambda 表达式，编译器会自动生成一个类，在该类中重载了 operator() 。

4.模板参数中的lambda表达式

如果给一个优先级队列priority_queue传入一个less仿函数，如下

priority_queue<int, vector<int>, less<int>> q;

其中less<int>是仿函数，但是less<int>不是仿函数实例化出的对象，而是一个仿函数类型。也就是说，模板参数中需要的不是仿函数对象，而是仿函数类型。但是lambda表达式整体返回的类型是仿函数对象，因此以下写法是错误的：

priority_queue<int, vector<int>, [](const int& i1, const int& i2) {return i1 < i2; } > q;

我们不能直接把lambda当作模板参数传入，此时就要使用decltype来推导原先的类型：

auto intLess = [](const int& i1, const int& i2) {return i1 < i2; };
priority_queue<int, vector<int>, decltype(intLess)> q;

5.类中的lambda表达式

在C++中，Lambda表达式可以在类的成员函数中正常使用，就像在全局作用域或函数内部一样。Lambda表达式可以捕获类的成员变量，包括this指针，以便在Lambda表达式的函数体内访问和修改这些成员变量。这使得Lambda表达式成为定义临时、一次性操作的理想选择，尤其是在需要作为回调函数或传递给标准库算法时。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class MyClass {
	int value;
public:
	MyClass(int initialValue) : value(initialValue) {}
	void incrementValue() {
		// 使用Lambda表达式来增加value的值
		auto incLambda = [this]() mutable { ++this->value; };
		incLambda();
	}
	void printValue() const {
		// 使用Lambda表达式来打印value的值
		auto printLambda = [this]() { cout << "Value: " << this->value << endl; };
		printLambda();
	}
};

int main() {
	MyClass obj(5);
	obj.incrementValue();
	obj.printValue(); // 应该输出 Value: 6
	return 0;
}

当然也可以使用[&]直接访问this指针和成员变量。