lambda表达式【C++】

lambda表达式

lambda表达式是C++11最重要也是最常用的一个特性。lambda来源于函数式编程的概念。

优点：

• 声明式编程风格：就地匿名定义目标函数或函数对象，不需要额外写一个命名函数或函数对象。
• 以更直接的方式去写程序，有好的可读性和可维护性。
• 简洁：不需要额外再写一个函数或函数对象，避免了代码膨胀和功能分散，让开发者更加集中精力在手边的问题，同时也获取了更高的生产率。

定义:

[capture] (params) opt →ret {body;} ;

例子：

int main()
{
    auto f = [](int a) -> int { return a + 1; };
    int x = 5;
    x = f(x);
    cout << x << endl;// 6 
}

lambda表达式可以通过捕获列表捕获一定范围内的变量：

[ ] 不捕获任何变量
[&] 捕获外部作用域中所有变量，并作为引用方式捕获来使用 当前所处函数中
[=] 捕获外部作用域中所有变量，并作为值方式捕获来使用 在定义时就捕获到当前值
[=，&foo] 按值捕获外部作用域中所有变量，并按引用捕获foo变量
[bar] 按值捕获bar变量，同时不捕获其他变量
[this] 捕获当前类中的this指针，让lambda表达式拥有和当前类成员函数同样的访问权限。如果已经使用& or =,就默认添加此选项。捕获this的目的是可以在lambda中使用当前类的成员函数和成员变量。

对于全局变量，没有“捕获”这个概念。 lambda表达式本质上是仿函数，来代替仿函数。

使用一下

int g_max = 10;
class Object
{
	int value;
public:
	Object(int x = 0) :value(x)
	{
		cout << "construct object" << this << endl;
	}

	void func(int a, int b)
	{
		auto x0 = []()->int {return g_max; };//ok 全局变量不需要捕获就可以使用

		auto x1 = []()->int {return a; }; //error []为不捕获外部变量

		//捕获外部作用域中所有变量，按值捕获(包括全局变量和this指针)
		auto x2 = [=]()->int {
			int x = value;
			return x + a + g_max;
		};//[=]捕获外部作用域中的所有变量，按值捕获(func函数中形参个this指针以及局部变量)

		auto x3 = [this](int c)->int {
			value += 10;
			return value + c;
		};//[this] 只是捕获this指针，不捕获func函数中的形参和局部变量

		auto x5 = [this]()->void {value = a + b; };//error 只是捕获this'指针，不捕获a，b

		auto x6 = [this, a, b]()->void {value = a + b; };//只是捕获this指针，a，b

		auto x7 = [this] {return value++; };
	}
	
};

int main()
{
	int a = 10, b = 20;
	Object obj(10);
	obj.func(12, 23);

	auto f1 = [] {return a};//error []不捕获外部变量
	auto f2 = [&] {return a++; };//ok 以引用捕获，对a进行自加运算
	auto f3 = [=] {return a; };//ok  按值捕获
	auto f4 = [=] {return a++; };//error 按值捕获，不能修改值
	auto f5 = [a] {return a + b; };//error 没有捕获除a之外的变量
	auto f6 = [a, &b] {return a + (++b); };//ok 按引用捕获a，b，对b进行自加运算
	auto f7 = [=, &b] {return a + (b++); };//ok 按值捕获外部所有变量，并按引用捕获b，对b做自加运算

	return 0;
}

总结一个规律就是，如果只是对变量进行读操作，那么无需按引用捕获外部变量，若是想要修改变量的值，则以引用捕获。但，还有一个问题是，lambda表达式是延迟调用的：

int g_max = 10;
int func(int a, int b)
{
	int c = a + b;
	return c;
}

int main()
{
	int a = 0;
	{
		int x = 10;
	}
	auto funa = [=] {return a; };//按值捕获，a的副本不可以修改
	//auto funb = [=] {return x; };//error x变量是块内作用域

	a += 100;
	cout << funa() << endl;//a是0，因为在定义的时候，就将a的值进行了捕获
	cout << typeid(funa).name() << endl;
	return 0;
}

lambda表达式按值捕获了所有外部变量的值，在捕获的一瞬间，a的值就已经被复制到funa中了，之后a被修改，但此时funa中存储的仍然是捕获时的值，因此，最终输出结果是0。若希望lambda表达式在调用时能够即时访问外部变量。我们就需要按引用捕获。

那么，如果我们想要去修改按值捕获的外部变量应该怎么做？可以显示指明lambda表达式为mutable：

int main()
{
	int a = 0;
	auto f1 = [=] {return a++; }; //error 修改按值捕获外部变量
	auto f2 = [=]()mutable {return a++; };//ok mutable
}

注意：被mutable修饰的lambda表达式就算没有参数也要写明参数列表。

lambda表达式的类型

lambda表达式的类型在C++11中被称为“闭包类型”，是一个特殊的，匿名的非nuion的类型。因此，可以简单理解为它是一个带有operator()的类，即仿函数。因此，我们就可以使用std::function和std::bind来存储和操作lambda表达式：

#include<iostream>
#include<functional>
using namespace std;


int main()
{
	int x = 0;
	std::function<int(int)> f1 = [](int a) {return a; };
	std::function<int(void)> f2 = std::bind([] (int a) { return a; }, 123);
	x = f1(10);//x=10;
	x = f2();//x=123
	cout << x << endl;//123
	return 0;
}

lambda表达式就是就地定义仿函数闭包的”语法糖”。它所捕获到的任何外部变量，最终均会变为闭包类型的成员变量。而一个使用了成员变量的类的operator()， 如果能直接被转换为普通的函数指针，那么lambda表达式本身的this指针就丢失掉了。

而没有捕获任何外部变量的lambda 表达式则不存在这个问题。这就也可以很自然地解释为何按值捕获无法修改捕获的外部变量。因为按照C++标准，lambda 表达式的operator() 默认是const的。一个const成员函数是无法修改成员变量的值的。而mutable的作用，就在于取消operator()的 const。 需要注意的是，没有捕获变量的lambda 表达式可以直接转换为函数指针，而捕获变量的lambda表达式则不能转换为函数指针。

typedef void (*ptr)(int*);
	//OK 没有捕获外部变量的lambda表达式可以直接转换为函数指针
	ptr p = [](int* p) {delete p; };
	//error 捕获外部变量的lambda表达式不能转换为函数指针
	ptr p1 = [&](int* p) {delete p; };