C++——lambda表达式

介绍

lambda表达式是一种局部类类型，它含有一个构造函数，和一个const成员函数operator()()。

lambda表达式除了能做参数外，还能用于初始化一个声明为auto或者std::function<R(LA)>的变量。R是lambda的返回类型，LA是它的类型参数列表。

组成部件

1. 一个可能为空的捕获列表，指明定义环境中哪些名字能够被用在lambda表达式中，以及这些名字是被拷贝还是引用。捕获列表位于[]中。 补充： 静态变量不能也不需要被捕获。
2. 一个可选的参数列表。指明所需要的参数，位于()中。补充 当无参数时，可以省略。
3. 一个可选的mutable修饰符，当需要修改通过值捕获的变量的副本时，位于()之后。
4. 一个可选的noexcept修饰符，表明无异常被抛出。位于mutable修饰符之后。
5. 一个可选的->形式的返回类型声明，可与decltype一起搭配使用。
6. 一个表达式体，指明要执行的代码，位于{}块中。

实现模型

对于lambda表达式而言，有着很多种表述方法，并且有着多中优化途径。如果把lambda表达式看成是一种定义并使用函数对象的便捷方式，那么便于理解。

假设有这么一个例子：

void print_modulo(const vector<int>& v, ostream& os, int m)
{
	for_each(begin(v), end(v),
		[&os, m](int x) {if (x % m == 0) os << x << '/n';}
	);
}

我们可以将其中的lambda表达式改写成一个函数对象：

class Modulo_print
{
	ostream& os;
	int m;
public :
	Modulo_print(ostream& s, int mm) :os{ s }, m{ mm } {}
	void operator() (int x) const 
	{
		if (x % m == 0) os << x << '/n';
	}
};

并且改写之前的例子：

void print_modulo(const vector<int>& v, ostream& os, int m)
{
	for_each(begin(v), end(v),Modulo_print{os, m});
}

我们把由lambda表达式生成的函数对象称为闭包对象 (闭包)。

如果lambda表达式通过引用 ([&]) 捕获它定义环境中的每一个局部变量，则其闭包对象则可以优化为简单的包含一个指向外层栈框架的指针。

捕获

lambda表达式的主要用途是封装一部分代码以便将其用做参数。

有些lambda表达式无需访问它的局部环境，这样lambda表达式使用空引入符 [ ] 定义。

lambda引入符的形式有很多：

1. [ ]空捕获列表，在lambda表达式内部无法使用其外层上下文中的任何局部名字，其数据需要从实参或者非局部变量中获得。
2. [&]通过引用隐式捕获。所有局部变量通过引用使用。
3. [=]通过值隐式捕获。所有局部变量通过拷贝使用，这些副本是在lambda表达式的调用点获得的。
4. [捕获列表] 显式捕获。通过引用或者值方式捕获其局部变量。捕获列表中可以出现this (通过值方式捕获) 和 紧跟…的名字以表示的元素。
5. [&, 捕获列表] 对于出现在捕获列表中的名字以值方式捕获，不能以&为名字前缀。捕获列表可以出现this。
6. [=, 捕获列表] 对于出现在捕获列表中的名字以引用方式捕获，必须以&为前缀，捕获列表中不能出现this。

对于lambda表达式来说，当把lambda传递给另一个线程时，用值捕获更优，通过引用或者指针访问其他线程中的内容是一种危险操作，对于性能和正确性来说都是如此。

对于可变模板参数的捕获示例：

template <typename...Var>
void algo(int s, Var... var)
{
auto helper = [&s, &var...]{return s * (h1(var...) + h2(var...)); };
}

生命周期

lambda表达式的生命周期可能比它的被调用者更长。当我们把lambda表达式传递给另一个线程或者存在别处以供后续使用的时候。
例如：

void setup(Menu& m)
{
Point p1, p2, p3;
m.add("draw a triangle", [&]{m.draw(p1, p2, p3); }); //可能会发生程序错误
}

当setup完成之后，我们可能需要画一个三角型，此时lambda表达式将会访问一个已经不存在的局部变量。

如果我们发现一个lambda表达式的生命周期可能比它的调用者更长，则我们需要确保所有局部信息都已经被拷贝到闭包对象中去。

m.add("draw a triangle", [=]{m.draw(p1, p2, p3); });

lambda与this

当lambda表达式被用在成员函数当中，我们怎样去访问类成员变量呢？我们通过捕获this指针来访问类成员对象。
例如:

template <typename T>
class Request
{
	typedef typename vector<T>::value_type result;

	function<result(const vector<T>&)> oper;
	vector<T> values;
	result results;
public:
	void execute()
	{
		[this] {results = oper(values);};
	}
};

类成员变量是通过this访问的，在lambda表达式中[this] 和 [=] 互不兼容，因此一不小心就可能在多线程程序中造成竞争条件。

mutable的lambda表达式

如果希望在lambda表达式修改函数对象的状态，即修改通过值捕获的变量，则可以使用mutable修饰符：

void algo()
{
	int count = 100;
	[count]()mutable {return --count;};
}

lambda表达式与返回类型

lambda表达式的大多数规则都是从类和函数借鉴过来的，然而需要有两点需要注意：

1. 如果lambda表达式不需要任何参数，则参数列表可以省略。因此lambda表达式的最简形式是[]{}。
2. lambda表达式的返回类型可以有其本身推断得到，而函数(方法)不行。

如果在一条lambda表达式的主体部分不包含return语句，则其返回类型为void。
如果lambda表达式只包含一条return语句，则返回类型是return表达式的类型。 其他情况，必须显式定义一个返回类型。

lambda表达式的类型

任意两个lambda表达式的类型都不相同，一旦两个lambda表达式的类型相同，则模板实例化机制就无法识别它们了。

例如：

auto algo = [&algo](char* b, char* a) {
		swap(*b, *--a); algo(++b, a);
	};

由于algo的类型并没有在使用之前被推断出来，因此上面的写法是错误的。

使用function包装器可以存入函数对象。就可以保证，在使用之前, algo的类型就已经知道了。

	function<void (char*b, char*a)>  algo = [&](char* b, char* a) {
		swap(*b, *--a); algo(++b, a);
	};

如果我们只是想给lambda表达式起个名字，而不会在主体内部递归的使用它。则：

auto algo = [&](char* b, char* a) {swap(*b, *--a); };

是没有问题的。

如果lambda表达式什么也不捕获，则我们可以把它赋值给一个指向正确类型的函数指针。

	double (*fun) (double a) = [](double a) {return sqrt(a);};

但行好事， 莫问前程！