共计 5380 个字符，预计需要花费 14 分钟才能阅读完成。
阐明一下，我用的是 gcc7.1.0 编译器，规范库源代码也是这个版本的。
本篇文章解说 c ++11 中 lambda 表达式用法。
首次接触 lambda 这个关键字，记得还是在 python 外面，但其实，早在 2011 年 c ++11 推出来的时候咱们 c ++ 就有了这个关键字啦。lambda 表达式是 C ++11 中引入的一项新技术，利用 lambda 表达式能够编写内嵌的匿名函数，用以替换独立函数或者函数对象，并且使代码更可读。
所谓函数对象，其实就是对 operator()进行重载进而产生的一种行为，比方，咱们能够在类中，重载函数调用运算符 (), 此时类对象就能够间接相似函数一样，间接应用() 来传递参数，这种行为就叫做函数对象，同样的，它也叫做仿函数。
如果从狭义上说，lambda 表达式产生的是也是一种函数对象，因为它也是间接应用 () 来传递参数进行调用的。
1 lambda 表达式根本应用
lambda 表达式根本语法如下：
[捕捉] (形参) -> ret {函数体};lambda 表达式个别都是以方括号 [] 结尾，有参数就应用 ()，无参就间接省略() 即可，最初完结于{}，其中的 ret 示意返回类型。
咱们先看一个简略的例子，定义一个能够输入字符串的 lambda 表达式，残缺的代码如下：
#include <iostream>
int main()
{auto atLambda = [] {std::cout << "hello world" << std::endl;};
atLambda();
return 0;
}下面定义了一个最简略的 lambda 表达式，没有参数。如果须要参数，那么就要像函数那样，放在圆括号外面，如果有返回值，返回类型则要放在 -> 前面，也就是尾随返回类型，当然你也能够疏忽返回类型，lambda 会帮你主动推导出返回类型，上面看一个较为简单的例子：
#include <iostream>
int main()
{auto print = [](int s) {std::cout << "value is" << s << std::endl;};
auto lambAdd = [](int a, int b) ->int {return a + b;};
int iSum = lambAdd(10, 11);
print(iSum);
return 0;
}lambAdd 有两个入参 a 和 b，而后它的返回类型是 int，咱们能够试一下把 ->int 去掉，后果是一样的。
2 lambda 捕捉块
2.1 捕捉的简略应用
在第 1 节中，咱们展现了 lambda 的语法模式，前面的形参和函数体之类都好了解，那么方括号外面捕捉是啥意思呢？
其实这里波及到 lambda 表达式一个重要的概念，就是闭包。
这里咱们须要先对 lambda 表达式的实现原理做一下阐明：当咱们定义一个 lambda 表达式后，编译器会主动生成一个匿名类，这个类外面会默认实现一个 public 类型的 operator()函数，咱们称为闭包类型。那么在运行时，这个 lambda 表达式就会返回一个匿名的闭包实例，它是一个右值。
所以，咱们下面的 lambda 表达式的后果就是一个一个的闭包。闭包的一个弱小之处是能够通过传值或者援用的形式捕捉其封装作用域内的变量，后面的方括号就是用来定义捕捉模式以及变量，所以咱们把方括号 [] 括起来的局部称为捕捉块。
看这个例子：
#include <iostream>
int main()
{
int x = 10;
auto print = [](int s) {std::cout << "value is" << s << std::endl;};
auto lambAdd = [x](int a) {return a + x;};
auto lambAdd2 = [&x](int a, int b) {return a + b + x;};
auto iSum = lambAdd(10);
auto iSum2 = lambAdd2(10, 11);
print(iSum);
print(iSum2);
return 0;
}当 lambda 块为空时，示意没有捕捉任何变量，不为空时，比方下面的 lambAdd 是以复制的模式捕捉变量 x，而 lambAdd2 是以援用的形式捕捉 x。那么这个复制或者援用到底是怎么体现的呢，咱们应用 gdb 看一下 lambAdd 和 lambAdd2 的具体类型，如下：
(gdb) ptype lambAdd
type = struct <lambda(int)> {int __x;}
(gdb) ptype lambAdd2
type = struct <lambda(int, int)> {int &__x;}
(gdb)后面咱们说过 lambda 实际上是一个类，这里失去了证实，在 c ++ 中 struct 和 class 除了有少许区别，其余都是一样的，所以咱们能够看到复制模式捕捉实际上是一个蕴含 int 类型成员变量的 struct，援用模式捕捉实际上是一个蕴含 int& 类型成员变量的 struct，而后在运行的时候，会应用咱们捕捉的数据来初始化成员变量。
既然有初始化，那么必然有构造函数啊，而后捕捉生成的成员变量，有 operator()函数，临时来讲，一个比拟平面的闭包类型就存在于咱们脑海中啦，对于 lambda 表达式类型具体组成，咱们临时放一放，接着说捕捉。
2.2 捕捉的类型
捕捉的形式能够是援用也能够是复制，然而到底有哪些类型的捕捉呢？
捕捉类型如下：
- []：默认不捕捉任何变量；
- [=]：默认以复制捕捉所有变量；
- [&]：默认以援用捕捉所有变量；
- [x]：仅以复制捕捉 x，其它变量不捕捉；
- [x…]：以包开展形式复制捕捉参数包变量；
- [&x]：仅以援用捕捉 x，其它变量不捕捉；
- [&x…]：以包开展形式援用捕捉参数包变量；
- [=, &x]：默认以复制捕捉所有变量，然而 x 是例外，通过援用捕捉；
- [&, x]：默认以援用捕捉所有变量，然而 x 是例外，通过复制捕捉；
- [this]：通过援用捕捉以后对象（其实是复制指针）；
- [*this]：通过复制形式捕捉以后对象；
能够看到，lambda 是能够有多个捕捉的，每个捕捉之间以逗号分隔，另外呢，不论多少种捕捉类型，万变不离其宗，要么以复制形式捕捉，要么以援用形式捕捉。
那么复制捕捉和援用捕捉到底有什么区别呢？
规范 c ++ 规定，默认状况下，在 lambda 表达式中，对于 operator()的重载是 const 属性的，也就意味着如果以复制模式捕捉的变量，是不容许批改的，看这段代码：
#include <iostream>
int main()
{
int x = 10;
int y = 20;
auto print = [](int s) {std::cout << "value is" << s << std::endl;};
auto lambAdd = [x](int a) {
// x++; 此处 x 是只读，不容许自增，编译会报错
return a + x;
};
auto lambAdd2 = [&x](int a, int b) {
x = x+5;
return a + b + x;
};
auto iSum = lambAdd(10);
auto iSum2 = lambAdd2(10, 11);
print(iSum);
print(iSum2);
return 0;
}从代码能够看出，复制捕捉不容许批改变量值，而援用捕捉则容许批改变量值，为什么呢，这里我了解，&x 实际上是一个 int* 类型的指针，所以咱们能够批改 x 的值，因为咱们只是对这个指针所指向的内容进行批改，并没有对指针自身进行批改，且与咱们惯例申明的援用类型入参一样，批改的值在 lambda 表达式外也是无效的。
那么如果我想应用复制捕捉，又想批改变量的值呢，这时咱们就想起来有个关键字，叫做 mutable，它容许在常成员函数中批改成员变量的值，所以咱们能够给 lambda 表达式指定 mutable 关键字，如下：
#include <iostream>
int main()
{
int x = 10;
int y = 20;
auto print = [](int s) {std::cout << "value is" << s << std::endl;};
auto lambAdd = [x](int a) mutable {
x++;
return a + x;
};
auto iSum = lambAdd(10);
print(iSum);
print(x);
return 0;
}执行后果如下：
value is 21
value is 10所以加上 mutable 当前就能够对复制捕捉进行批改，但有一点，它的批改出了 lambda 表达式当前就有效了。
2.3 包开展形式捕捉
认真看 2.2 节中捕捉类型，会发现有 [x…] 这样的类型，它实际上是以复制形式捕捉了一个可变参数，在 c ++ 中其实波及到了模板形参包，也就是变参模板，看上面例子：
#include <iostream>
void tprintf()
{return;}
template<typename U, typename ...Ts>
void tprintf(U u, Ts... ts)
{auto t = [ts...]{tprintf(ts...);
};
std::cout << "value is" << u << std::endl;
t();
return;
}
int main()
{tprintf(1,'c',3, 8);
return 0;
}它捕捉了一组可变的参数，不过这里实际上是为了演示对可变参数的捕捉，强行应用了 lambda 表达式，不应用的话，代码可能更加简洁，咱们只须要通过这个演示晓得怎么应用即可，另外对于变参模板的应用，这里就不开展来讲了。
2.4 捕捉的作用
我再看 lambda 的捕捉的时候始终很奇怪，初看的话，这个捕捉跟传参数有什么区别呢，都是把一个变量值传入 lambda 表达式体供应用，但认真思考的话，它是有作用的，假如有这么一个案例，一个公司有 999 名员工，每个员工的工号是从 1~999，咱们当初想找出工号是 8 的整数倍的所有员工，一个可行的代码如下：
#include <iostream>
#include <array>
int main()
{
int x = 8;
auto t = [x](int i){if ( i % x == 0)
{std::cout << "value is" << i << std::endl;}
};
auto t2 = [](int i, int x){if ( i % x == 0)
{std::cout << "value is" << i << std::endl;}
};
for(int j = 1; j< 1000; j++)
{t(j);
t2(j, x);
}
return 0;
}表达式 t 应用了捕捉，而表达式 t2 没有应用捕捉，从代码作用和量来看，它们其实区别不大，但有一点，对于表达式 t，x 的值只复制了一次，而对于 t2 表达式，每次调用都要生成一个长期变量来寄存 x 的值，这其实是多了工夫和空间的开销，不过，对于这段代码而言，这点耗费能够忽略不计呢，但一旦数据上了规模，那就会有比拟大的区别了。
对于捕捉的作用，我临时只想到了这一点，如果有大佬晓得更多的作用，麻烦说一下呀。
对于捕捉，还是尽量不要应用 [=] 或者 [&] 这样全捕捉的模式，因为不可控，你不能确保哪些变量会被捕捉，容易产生一些意外的行为。
3 lambda 表达式作为回调函数
lambda 表达式一个更重要的利用是它能够作为函数的参数传入，通过这种形式能够实现回调函数。比方在 STL 算法中，常常要给一些模板类或者模板函数来指定某个模板参数为 lambda 表达式，就想上一节说的，我想统计 999 个员工中工号是 8 的整数倍的员工个数，一个可用的代码如下：
#include <iostream>
#include <array>
#include <algorithm>
int main()
{
int x = 8;
std::array<int, 999> arr;
for (int i =1; i< 1000; i++)
{arr[i] = i;
}
int cnt = std::count_if(arr.begin(), arr.end(), [x](int a){return a%x == 0;});
std::cout << "cnt=" << cnt << std::endl;
return 0;
}这里很显著，咱们指定了一个 lambda 表达式来作为一个条件，更多时候，是应用排序函数的时候，指定排序准则，也能够应用 lambda 表达式。
4 lambda 表达式赋值
lambda 表达式既然生成了一个类对象，那么它是否能够像一般类对象那样，进行赋值呢？
咱们写一段代码试一下：
#include <iostream>
using namespace std;
int main()
{auto a = [] {cout << "A" << endl;};
auto b = [] { cout << "B" << endl;};
//a = b; // 非法，lambda 无奈赋值
auto c(a); // 非法，生成一个正本
return 0;
}很显然赋值不能够，而拷贝则能够，联合编译器主动生成构造函数规定，很显著，赋值函数被禁用了，而拷贝构造函数则没有被禁用，所以不能用一个 lambda 表达式给另外一个赋值，但能够进行初始化拷贝。
5 总结
总而言之，依据 lambda 表达式的一个定义来看，它其实是用于代替一些性能比较简单，但又有大量应用的函数，lambda 在 stl 中大量应用，对于大部分 STL 算法而言，能够非常灵活地搭配 lambda 表达式来实现想要的成果。
同时这里要阐明一下，lambda 其实是作为 c ++11 新引入的一种语法规定，它与 STL 并没有什么间接关联，只是 STL 外面大量应用了 lambda 表达式而已，并不能间接就说把它当做是 STL 的一部分。
