C++11中的lambda与线程。

Lambda：

假设我们有一个商品类，需要对指定的元素进行排序。

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());

	return 0;
}

随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个比较算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别命令更是关键，最好是可以清晰反映该仿函数功能的。

而且，如果该仿函数是定义在别的文件且命名不规范，打包为动态库我们无法得知该仿函数的功能。

这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。

我们可以将Lambda看作为函数内定义的函数。方便接受理解。

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使用示例：

有了usage当然要看一看具体如何使用啦。

两数相加：

auto add = [](int x, int y)->int { return x + y; };
int ret = add(1, 5);
cout << ret << endl;

和普通函数很像：
返回值（->int），参数(int x, int y)，函数体 { return x + y; }。

两数交换：

我们先来看如下的lambda语句是否正确？

auto swap = [](int x, int y)-> void
{
	int tmp = x;
	x = y;
	y = tmp;
};

显然是错误的，实际上我们的x与y也就是普通的传值

因此我们传引用即可解决。

那么捕捉列表是干啥用？
在这之前我们要知道lambda的作用域与当前函数的域不是父域子域的关系，而是独立的一个域，也就是说lambda是用不了外部域的对象的。

但是我们可以进行捕捉进而使用外部作用域对象。
即在捕捉列表中进行输入你想捕捉的对象即可。

但是这样会报错，原因在于我们默认捕捉得到的参数是自带const的值复制捕捉。我们在前面的语法也提到过，因此我们可以加上mutable即可去掉const属性。

结果：

仍旧没有成功交换，是因为我们的捕捉得到的是传值的，所以这也侧面说明其实mutable的作用不是很大，我们也不常用，只有在特定情境下才有用处。

所以我们在a，b前加上&即可引用。

另外，如果我们需要捕捉的参数过多，也可以全部引用捕捉，或者值复制捕捉，或者混合捕捉，十分灵活。

[&]() {}; // 全部引用捕捉
[=]() {}; // 全部传值捕捉
[&, a]() {};  // 全部引用捕捉,a是传值捕捉
[=, &a]() {}; // 全部传值捕捉,a是引用捕捉

解决Goods排序问题：

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使用，以及使用的方式传值还是传引用。
[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针

注意：
a. 父作用域指包含lambda函数的语句块
b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量
c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复
d. 在块作用域以外的lambda函数捕捉列表必须为空。
e. lambda表达式之间不能相互赋值，即使看起来类型相同

void (*PF)();
int main()
{
	auto f1 = [] {cout << "hello world" << endl; };
	auto f2 = [] {cout << "hello world" << endl; };
	// 此处先不解释原因，等lambda表达式底层实现原理看完后，大家就清楚了
  //f1 = f2;  // 编译失败--->提示找不到operator=()
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f3(f2);
	f3();
	// 可以将lambda表达式赋值给相同类型的函数指针
	PF = f2;
	PF();
	return 0;
}

Lambda原理：

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

函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到。

因此我们得到结论，lambda底层就是仿函数，他的类名为lambda_uuid，uuid是一个几乎不会发生重复的数字生成器，所以对象大小为1，类型不同不能相互赋值。