C11简洁之道：lambda表达式
1、 定义
lambda表达式是C++11非常重要也是很常用的特性之一，来源于函数式编程的概念，也是现代编程语言的一个特点。它有如下特点：
- 声明式编程风格：就地匿名定义目标函数或者函数，不需要额外写一个命名函数或者函数对象，以更直接的方式写程序。
- 简洁：不需要额外再写一个函数或者函数对象，避免了代码膨胀和功能分散。
- 在需要的时间和地点实现功能闭包，使程序更加灵活。
lambda表达式定义一个匿名函数，并且可以捕获一定范围内的变量，其定义如下：
[captrue] (params) opt -> ret {body};
其中，capture是捕获列表；params是参数列表；opt是函数选项；ret是返回值类型；body是函数体。
我们来做一个简单的例子，定义一个简单的封包，用来将输入的结果+1并返回。
auto f = [](int a) -> int {return a + 1; }; std::cout << f(1) << std::endl;
lambda表达式的返回值通过返回值后置语法来定义，所以很多时候可以省略返回值类型，编译器根据return语句自动推导返回值类型。
auto f = [] (int a) {return a + 1;};
但是初始化列表不能作为返回值的自动推导，需要显示给出具体的返回值类型。
auto f1 = [] (int a) {return a + 1;}; //ok,return type is int auto f2 = [] () {return {1, 2}}; //error:无法推导出返回值类型
lambda表达式在没有参数列表的时候，参数列表可以省略。
auto f1 = [] () {return 1;};
auto f2 = [] {return 1;} //省略空参数表
2、 捕捉
lambda表达式可以通过捕获列表捕获一定范围内的变量：
- []不捕获任何变量；
- [&]捕获外部作用域所有变量，并作为引用在函数体使用（按引用捕获）；
- [=]捕获外部作用域作用变量，并作为副本在函数体使用（按值捕获）；
- [=,&foo]按值捕获外部作用域所有变量，并按引用捕获foo变量；
- [bar]按值捕获bar变量，同时不捕获其他变量；
- [this]捕获当前类中的this指针，让lambda拥有和当前类成员函数同样的访问权限，如果已经使用了&或者=，就默认添加此选项。捕获this的目的是可以在lambda中使用当前类的成员函数和成员变量。
class A { public: int mi = 0; void func(int x, int y) { auto x1 = []{return mi;}; //error,没有捕获外部变量 auto x2 = [=] {return mi + x + y;}; //ok，按值捕获所有外部变量 auto x3 = [&] {return mi + x + y;}; //ok,按引用捕获所有外部变量 auto x4 = [this] {return mi;}; //ok,捕获this指针 auto x5 = [this] {return mi + x + y;}; //error，没有捕获x,y auto x6 = [this,x,y] {return mi + x + y;}; //ok，捕获this，x，y auto x7 = [this] {return mi++;}; //ok,捕获this指针，并修改成员的值 } }; int a = 0, b = 2; auto f1 = [] {return a;} ; //error,没有捕获外部变量 auto f2 = [&] {return a++;}; //ok,按引用捕获所有外部变量，并对a执行自加运算 auto f3 = [=] {return a;}; //ok,按值捕获所有外部变量，并返回a auto f4 = [=] {return a++;}; //error,按值引用不能改变值 auto f5 = [a] {return a + b;}; //error,没有捕获b auto f6 = [a, &b] {return a + (b++);}; //ok,捕获a和b的值，并对b做自加运算 auto f7 = [=, &b] {return a + (b++);}; //ok,捕获所有外部变量和b的引用，并对b做自加运算
从例子中可以看到，lambda表达式的捕获列表精细的控制表达式能够访问的外部变量，以及如何访问这些变量。需要注意的是，默认状态下的lambda表达式无法修改通过复制方式捕获的外部变量，如果希望修改这些变量，需要用引用的方式进行修改。但是按值引用的话，如果延迟调用，那么在调用该lambda表达式的时候，其捕获的变量值还是在lambda定义的时候的值。
int a = 0; auto f = [=] {return a;}; //按值捕获外部变量 a += 1; //修改值 std::cout << f() << std::endl; //输出0
这个例子中，lambda表达式按值捕获了所有外部变量，在捕获的一瞬间a的值就已经被赋值在其中，之后a值修改并不会改变lambda表达中存的a的值，因此最终结果输出还是0。如果希望lambda表达式在调用的时候能即时访问外部变量，应当使用引用的方式捕获。
如果希望去修改按值捕获的外部变量，需要显示指明lambda表达式为mutable，但是被mutable修饰的lambda表达式有一个特点，就是无论有没有参数都要写明参数列表。
int a = 0; auto f1 = [=] {return a++;}; //error，不能修改按值捕获的变量 auto f2 = [=] mutable {return a++; }; //ok,mutable
lambda表达式其实是一个带有operator()的类，即仿函数，因此我们可以使用std::bind和std::function来存储和操作lambda表达式：
std::function<int(int)> f1 = [] (int a){ return a;}; std::function<int(void)> f2 = std::bind([](int a) {return a}, 123);
对于没有捕获任何变量的lambda表达式，还可以被转换成一个普通的函数指针：
using func_t = int(*)(int); func_t f = [](int a){return a;}; f(123);
lambda表达式可以说是定义仿函数闭包的语法糖，它捕获的任何外部变量都会转换为闭包类型的成员变量。而使用成员变量的类的operator(),如果能直接转换为普通的函数指针，那lambda表达式本身的this指针会丢失，没有捕获任何外部变量的lambda表达式则不存在这个问题，所以按值捕获的外部变量无法修改。因为lambda表达式中的operator()默认是const的，一个const成员函数无法修改成员变量的值，而mutable则是取消operator()的const。
所以，没有捕获变量的lambda表达式可以直接转换为函数指针，而捕获变量的lambda表达式则不能转换为函数指针。
typedef void(*Ptr)(int *); Ptr p1 = [](int *p) {delete p;}; //ok,没有捕获的lambda表达式可以转换为函数指针 Ptr p2 = [&](int *p){delete p;}; //error，有捕获的lambda表达式不能直接转换为函数指针，不能通过编译
3、 简洁代码
就地定义匿名函数，不再需要定义函数对象，大大简化了标准库的调用。比如我们使用for_each将vector中的偶数打印出来。
class CountEven { private: int &micount; public: CountEven(int &count) : micount(count) {} void operator()(int val) { if(!(val & 1)) { ++micount; } } }; std::vector<int> v = {1, 2, 3, 4, 5, 6}; int count = 0; for_each(v.begin(), v.end(), CountEven(count)); std::cout << "The number:" << count << std::endl;
这样写比较繁琐，如果用lambda表达式，使用闭包概念来替换这里的仿函数。
std::vector<int> v = {1, 2, 3, 4, 5, 6}; int count = 0; for_each(v.begin(), v.end(), [&count] (int val) { if(!(val & 1)) { ++count; } });
在之前的例子中，使用std::bind组合多个函数，实现了计算集合中大于5小于10的元素个数。
using std::placeholders::_1; auto f = std::bind(std::logical_and<bool>(), std::bind(std::greater<int>(), std::placeholders::_1, 5), std::bind(std::less_equal<int>(), std::placeholders::_1, 10)); int count = std::count_if(coll.begin(), coll.end(), f);
通过lambda表达式可以轻松的实现类似的功能：
//查找大于5小于10的元素个数
int count = std::count_if(coll.begin(), coll.end(), [](int x) {return x > 5 && x < 10;})
lambda表达式比std::bind更加灵活和简洁，如果简单的逻辑处理，用lambda表达式来代替function，提升开发效率，效果会更好。
