c++11总结13——lambda表达式

1. lambda表达式的优点

1）声明式编程风格：就地匿名定义目标函数或函数对象，不需要额外写一个命名函数或函数对象；

2）简洁：不需要额外写一个函数或函数对象，避免了代码膨胀和功能分散；

3）在需要的时间和地点实现功能闭包，使程序更灵活；

2. 概念和基本用法

2.1 基本概念

lambda表达式定义了一个匿名函数，并且可以捕获一定范围内的变量。

基本格式为：

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

capture：捕获列表

params：参数表

opt：函数选项

ret：返回值类型

body：函数体

一个完整的例子如下所示：

auto f = [](int a) -> int {
	return a + 1;
};

cout << f(1) << endl;

上述代码实现了一个功能闭包，用来将输入加1并返回。

注意1：c++11中允许省略lambda表达式的返回值定义：

auto f = [](int a) {
	return a + 1;
};

编译器会根据return语句自动推导出返回值的类型。

注意2： 初始化列表不能用于返回值的自动推导

auto f1 = [](int i) {
	return i;   //OK
};

auto f2 = [](int i) {
	return { 1, 2 };   //error
};

 

注意3：lambda表达式在没有参数列表时，参数列表是可以省略的。

auto f3 = []() {
	return 0;
};

auto f4 = [] {
	return 1;
};

cout << f3() << endl; //0
cout << f4() << endl; //1

 

2.2 capture捕获列表

1）[]：不捕获任何变量；

2）[&]：捕获外部作用域中的所有变量，并作为引用在函数体中使用——引用捕获；

3）[=]：捕获外部作用域中的所有变量，并作为副本在函数体中使用——按值捕获；

4）[=，&foo]：按值捕获外部作用域中的所有变量，并按引用捕获foo变量；

5）[bar]：按值捕获bar变量，同时不捕获其他变量；

6）[this]：捕获当前类中的this指针，让lambda表达式拥有与当前成员函数同样的访问权限，捕获this的目的是可以在lambda中使用当前类的成员函数和成员变量；

//example1
class A
{
public:
	int i = 0;

	void func(int x, int y)
	{
		//auto t1 = [] { return i; };  //error: []代表不捕获外部变量
		auto t2 = [=] { return i + x + y;  }; //ok 按值捕获
		auto t3 = [&] { return i + x + y;  }; //ok 引用捕获
		auto t4 = [this] { return i;  };  //ok
		//auto t5 = [this] { return i + x + y;  }; //error 没有捕获x y
		auto t6 = [this, x, y] { return i + x + y;  };  //ok
		auto t7 = [this] { return i++;  }; //ok 捕获this指针 修改成员变量的值
	}
};

//example2
int a = 0, b = 1;
//auto t1 = [] { return a; };   //error: []代表不捕获外部变量
auto t2 = [=] { return a;  };   //ok 按值捕获
auto t3 = [&] { return a++;  }; //ok 引用捕获 返回自加运算
//auto t4 = [=] { return a++;  };  //error 按值捕获 不能修改a的值
//auto t5 = [a] { return a + b;  };  //error 没有捕获变量b
auto t6 = [a, &b] { return a + (b++);  }; //ok
auto t7 = [=, &b] { return a + (b++);  }; //ok 捕获所有外部变量和b的引用，变量b可修改

一个容易出错的使用示例：

int i = 1;
auto t8 = [=] {
	return i;
};

i += 1;

cout << t8() << endl;  //打印1 如果想即时访问外部变量，应使用引用捕获

如果想要修改按值捕获的外部变量，可以显时指明lambda表达式为mutable。按值捕获的函数可以看成是const，无法修改成员的值，mutable是可以取消其const。

int m = 1;
auto t9 = [=] { 
	return m++;   //error 值捕获 不可修改
};

auto t10 = [=]() mutable {
	return m++;   //ok
};

2.3 lambda表达式的类型

lambda表达式的类型在c++11中被称为“闭包类型（Closure Type）”。它是一个特殊的、匿名的非union的类类型。

可以使用std::function和std::bind来存储和操作lambda表达式。

std::function<int(int)> t11 = [](int a) {
	return a;
};

std::function<int(void)> t12 = std::bind([](int a) {
	return a;
}, 1);

对于没有捕获任何变量的lambda表达式，还可以转换为一个普通的函数指针。

using func_t = int(*)(int);
func_t t13 = [](int a) {
	return a;
};
t13(11);

3. 声明式的编程风格

目的：使代码更加简洁。

std::vector<int> v{ 1,2,3,4,5 };
int iCount = 0;
for_each(v.begin(), v.end(), [&iCount](int iResult) {
    if (!(iResult & 1))
	{
		++iCount;
	}
});

4. 在需要的时间和地点实现闭包

lambda表达式可以任意封装出功能闭包。

std::vector<int> v1{ 9,2,31,14,50 };
auto t14 = std::count_if(v1.begin(), v1.end(), [](int x) {  //返回符合条件的个数
	return x > 5 && x < 10;
});

cout << t14 << endl;  //1 

5. 总结

c++11引入函数式编程的概念中的lambda，让代码更加简洁，更灵活，也更强大，提高了开发效率，也提高了可维护性。