C++11- lambda表达式

---

一、lambda表达式的概念

lambda表达式来源于函数式编程的概念，是现代编程语言的一个特点。lambda表达式定义一个匿名函数，并且可以捕获一定范围内的变量。
优点

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

二、使用

1.使用形式

[capture] (params) opt -> ret { body;};
//eg
auto f = [](int a) -> int {return a+1 ;};

2.参数介绍

capture是捕获列表；params是参数表；opt是函数选项；ret是返回值类型；body是函数体；

[] 不捕获任何内容
[&] 捕获外部作用域中的所有变量，并作为引用在函数体内使用（按引用捕获）
[=] 捕获外部作用域中的所有变量，并作为副本在函数体内使用（按值捕获）
[=,&foo] 按值捕获外部作用域中的所有变量，并按值捕获foo变量（一般把=，&放在前面）
[bar] 只捕获bar变量
[this] 捕获当前类中的this指针，让lambda表达式拥有和当前成员函数同样的访问权限。如果使用了&或者=，就默认添加了this选项。,使用this的目的就是可以在lambda表达式中使用当前类的成员函数或者成员属性。

3.例子

三、使用实例

1. 关于作用域

• 关于外部作用域：外部作用域表示本函数内。[=]和[&]表示的是捕获本函数内的局部变量。下面这个例子中的外部作用域仅仅对main函数来说的；
• 全局变量任何函数都可以捕获

void fun()
{
	int a = 10;
}
int flg = 20;
int main()
{
	int b = 30;
	int d = 40;
	{
		int f = 50;
	}
	auto f1 = [](int)->int {return flg; };  //ok     全局变量任何函数都可以使用，lambda表达式类似一个仿函数，当然也可以使用了
	auto f2 = [](int)->int {return b; };    //error  不捕获任何变量 ，不能使用外部作用域的变量
	auto f3 = [](int)->int {return a; };    //error  不捕获任何变量 ， 即使捕获，也不能使用a，因为a不属于 ‘外部作用域’；外部作用域仅仅对main函数来说的；
	auto f4 = [=](int)->int {return b; };    //ok  
	auto f5 = [=](int)->int {return a; };    //error 
	auto f6 = [=] {return f; };			  //error  和上面的a是一样的错误
}

上面的例子中f1,f4是正确的；

2. C++11允许省略返回值类型和参数列表

（1）省略返回值类型：编译器可以通过return语句来推导返回值类型。

auto f1 = [](int i) {return i+1;};

（2）省略参数列表：在没有参数的时候可以省略。

auto f1 = []() {return 1;};
auto f2 = [] {return 1;};    //省略空的参数列表

3. 捕获列表的使用

1. [=]和[&]

[=]： 以副本的形式捕获，是值捕获。不能在lambda函数体中修改变量的值，可以理解为以const的方式进行的捕获。
[&] :以引用的方式进行的捕获，可以修改变量的值。

int flg = 20;
int main()
{
	int b = 30; 

	auto f0 = [] {return flg++; };
	auto f1 = [=] {return ++b; };	//error
	auto f2 = [&] {return ++b; };	
	f0();
	f2();
	cout << flg << " " << b << endl;
}

执行结果:上述代码f1有误，因为[=] 是以值传递的方式拷贝的副本，不能修改。把f1注释掉之后的执行结果为：21 31。

2.[this],[bar],[=,&bar]

在类的成员函数中的应用

class obj
{
	int i = 0;
public:
	void fun()
	{
		int a = 1, b = 2;
		auto f1 = [=] {return i++; };    //ok   在类中，[=] 捕获外部作用域所有变量，所以把this指针捕获进来了
		auto f2 = [] {return i++; };     //error
		auto f3 = [=, &b] {a++; b++; };  //error  a+错误
		auto f4 = [this, a, b] {return a + b + i; };  //ok
		auto f5 = [a] {return a + b; };   //error，只捕获了a
		
	}
};

特别注意：
f1以值捕获的方式，但是可以修改i的值，这是因为值捕获的是this（一个地址），我们不能修改this的指向，但是可以修改它指向的内容。就比如下面的这个，我们捕获的是p（一个地址），虽然不能修改p的值，但是*p 可以使用。

3.lambda表达式的延迟调用

按值捕获得到的外部变量的值是绑定在lambda表达式中的，无论什么时候调用这个lambda表达式，都是捕获那一刻变量的值。

4.mutable的使用（易变的）

如果我们希望改变[=]值捕获的变量的值，可以使用mutable来实现。
mutable可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空，也要写明是空参数列表）;
注意：还是以值捕获的方式，并不修改原来变量的值。

int main()
{
	int a = 0;
	//auto f1 = [=] {return a++; };			//error
	//auto f2 = [=] mutable {return a++; };   //error ，必须带参数列表
	auto f3 = [=]() mutable {
		a++; 
		cout << a << endl;  //并没有改变a原来的值，还是进行了拷贝，只是使a的常性去掉了，可以在lambda表达式的作用域中进行修改值
	};   //ok

	f3();
	cout << a << endl;
}

结果：并没有修改原来的a；地址是不一样的。

5.lambda表达式和函数指针

需要注意的是，没有捕获变量的 lambda表达式可以直接转换为函数指针，而捕获变量的 lambda表达式则不能转换为函数指针。看看下面的代码:

4.打印数组中偶数的个数

1. 利用仿函数

//打印偶数个数
class A
{
private:
	int& count;
public:
	A(int& c):count(c){}
	void operator()(int val)
	{
		if (val % 2 == 0)
		{
			++count;
		}
	}
};
int main()
{
	std::vector<int> vec = { 1,2,3,4,5,6,7,8 };
	int even_count = 0;  //偶数个数
	std::for_each(vec.begin(), vec.end(), A(even_count)); //无名对象
	cout << "偶数的个数:" << even_count << endl;
	return 0;
}

2.利用lambda表达式

上面的就等价于下面的：可以看出简洁了不少。

int main()
{
	std::vector<int> vec = { 1,2,3,4,5,6,7,8 };
	int even_count = 0;  //偶数个数
	auto f1 = [&](int val) {	if (val % 2 == 0) { ++even_count; }	};
	std::for_each(vec.begin(), vec.end(), f1);
	cout << "偶数的个数:" << even_count << endl;
	return 0;
}

也可以这样写

int main()
{
	std::vector<int> vec = { 1,2,3,4,5,6,7,8 };
	int even_count = 0;  //偶数个数
	
	std::for_each(vec.begin(), vec.end(),  [&](int val) 
	{	if (val % 2 == 0) 
		{ 
			++even_count; 
		}	
	});
	cout << "偶数的个数:" << even_count << endl;
	return 0;
}

结果：偶数的个数：4

3.有关for_each

void for_each(_II _F,_II _L,_Fn _op)
{
	for(;_F != _L;++_F)
	{
		op(*_F);
	}
}

注意：lambda表达式不能被赋值。

参考资料《深入应用C++11代码优化与工程级应用》