lambda

lambda这个词起源于数学上的λ，在C++中利用lambda表达式，可以方便的定义和创建匿名函数。lambda可以看做函数对象的升级版。改进了函数对象以下的缺点：

使用在泛型算法中的参数传递
比较性质/自定义操作
优先级队列
智能指针

lambda表达式语法

[捕获外部变量]（形参列表）->返回值{操作代码}；
如果lambda不需要返回值，那么返回值可以省略。也就是这样：
[捕获外部变量]（形参列表）{操作代码}；

捕获外部变量的方式：

[]:表示不捕获任何外部变量
[=]:以传值的方式捕获外部的所有变量
[&]:以传引用的方式捕获外部的所有变量
[this]:捕获外部的this指针
[=，&a]：以传值的方式捕获外部的所有变量，但是a变量以传引用的方式捕获
[a，b]：以传值的方式捕获外部变量a和b
[a,&b]：a以传值方式捕获，b以传引用的方式捕获

lambda底层实现原理

首先来看第一章，无参无返回值的lambda：

	auto func1 = [](){cout << "hello world!" << endl; };
	func1();

其对应的类：

template<typename T=void>
class TestLambda01
{
public:
	TestLambda01() {}
	void operator()()const
	{
		cout << "hello world!" << endl;
	}
};

再来看第二种lambda，参数为整型返回值为整型的：

	auto func2 = [](int a, int b)->int {return a + b; };
	cout<<func2(20, 30)<<endl;

其对应的类：

template<typename T = int>
class TestLambda02
{
public:
	TestLambda02() {}
	int operator()(int a, int b)const
	{
		return a+b;
	}
};

然后是以引用方式获取参数的lambda：

	int a = 10;
	int b = 20;
	auto func3 = [&]() // “a”: 无法在非可变 lambda 中修改通过复制捕获
	{
		int tmp = a;
		a = b;
		b = tmp;
	};
	func3();

其对应的类：

template<typename T = int>
class TestLambda03
{
public:
	TestLambda03(int &a, int &b):ma(a), mb(b) {}
	void operator()()const
	{
		int tmp = ma;
		ma = mb;
		mb = tmp;
	}
private:
	int &ma;
	int &mb;
};

现在我们来总结一下：
lambda中的捕获参数列表对应类中成员变量的类型，返回值和参数列表对应operator（）的返回值和参数列表。

lambda表达式代替switch

	map<int, function<int(int, int)>> caculateMap;
	caculateMap[1] = [](int a, int b)->int {return a + b; };
	caculateMap[2] = [](int a, int b)->int {return a - b; };
	caculateMap[3] = [](int a, int b)->int {return a * b; };
	caculateMap[4] = [](int a, int b)->int {return a / b; };

	cout << "选择:";
	int choice;
	cin >> choice;
	cout << "10 op 15:" << caculateMap[choice](10, 15) << endl;

lambda实现指针自定义删除器

// 智能指针自定义删除器 delete p; FILE* fclose(FILE*)
	unique_ptr<FILE, function<void(FILE*)>> 
		ptr1(fopen("data.txt", "w"), [](FILE *pf) {fclose(pf); });

lambda实现多种比较操作

class Data
{
public:
	Data(int val1 = 10, int val2 = 10) :ma(val1), mb(val2) {}
	//bool operator>(const Data &data)const { return ma > data.ma; }
	//bool operator<(const Data &data)const { return ma < data.ma; }
	int ma;
	int mb;
};

// 优先级队列
	//priority_queue<Data> queue;
	using FUNC = function<bool(Data&, Data&)>;
	priority_queue<Data, vector<Data>, FUNC> 
		maxHeap([](Data &d1, Data &d2)->bool
		{
			return d1.mb > d2.mb;
		});
	maxHeap.push(Data(10, 20));
	maxHeap.push(Data(15, 15));
	maxHeap.push(Data(20, 10));

这样就可以灵活的实现比较了，不论我是比较ma还是mb来确定大小。

参考文献

[1] 施磊．腾讯课堂——C++高级．图论科技，2020.7．