Lambda 表达式（Lambda Expression）是 C++11 引入的一个“语法糖”，可以方便快捷地创建一个“函数对象”。
从 C++11 开始，C++ 有三种方式可以创建/传递一个可以被调用的对象：
函数指针
仿函数（Functor）
Lambda 表达式
函数指针
函数指针是从 C 语言老祖宗继承下来的东西，比较原始，功能也比较弱：
无法直接捕获当前的一些状态，所有外部状态只能通过参数传递（不考虑在函数内部使用 static 变量）。
使用函数指针的调用无法 inline（编译期无法确定这个指针会被赋上什么值）。
// 一个指向有两个整型参数，返回值为整型参数的函数指针类型
int (*)(int, int);
// 通常我们用 typedef 来定义函数指针类型的别名方便使用
typedef int (*Plus)(int, int);
// 从 C++11 开始，更推荐使用 using 来定义别名
using Plus = int (*)(int, int);
仿函数
仿函数其实就是让一个类（class/struct）的对象的使用看上去像一个函数，具体实现就是在类中实现 operator()。比如：
class Plus {
public:
int operator()(int a, int b) {
return a + b;
}
};
Plus plus;
std::cout << plus(11, 22) << std::endl; // 输出 33
相比函数指针，仿函数对象可通过成员变量来捕获/传递一些状态。缺点就是，写起来很麻烦（码字比较多）。
Lambda 表达式
Lambda 表达式在表达能力上和仿函数是等价的。编译器一般也是通过自动生成类似仿函数的代码来实现 Lambda 表达式的。上面的例子，用 Lambda 改写如下：
auto Plus = [](int a, int b) { return a + b; };
一个完整的 Lambda 表达式的组成如下：
[ capture-list ] ( params ) mutable(optional) exception(optional) attribute(optional) -> ret(optional) { body }
capture-list：捕获列表。前面的例子 auto Plus = [](int a, int b) { return a + b; }; 没有捕获任何变量。
params：和普通函数一样的参数。
mutable：只有这个 Lambda 表达式是 mutable 的才允许修改按值捕获的参数。
exception：异常标识。暂时不必理解。
attribute：属性标识。暂时不必理解。
ret：返回值类型，可以省略，让编译器通过 return 语句自动推导。
body：函数的具体逻辑。
除了捕获列表，Lambda 表达式的其它地方其实和普通的函数基本一样。
Lambda 表达式的捕获，其实就是将局部自动变量保存到 Lambda 表达式内部（Lambda 表达式不能捕获全局变量或 static 变量）。
Lambda 表达式最常用的地方就是和标准库中的算法一起使用。下面我们用一个简单的例子来说明 Lambda 表达式的用法。
假设有一个书本信息的列表，定义如下。我们想要找出其中 title 包含某个关键字（target）的书本的数量，可以通过标准库中的 std::count_if + Lambda 表达式来实现。
struct Book {
int id;
std::string title;
double price;
};
std::vector<Book> books;
std::string target = “C++”; // 找出其中 title 包含“C++”的书本的数量
Lambda 表达式的最基本的两种捕获方式是：按值捕获（Capture by Value）和按引用捕获（Capture by Reference）。
按值捕获
auto cnt =
std::count_if(books.begin(), books.end(), [target](const Book& book) {
return book.title.find(target) != std::string::npos;
});
```
[target] 表示按值捕获 target。Lambda 表达式内部会保存一份 target 的副本，名字也叫 target。
按引用捕获
auto cnt =
std::count_if(books.begin(), books.end(), [&target](const Book& book) {
return book.title.find(target) != std::string::npos;
});
```
[&target] 表示按引用捕获 target——不会复制多一份副本。
捕获列表初始化（Capture Initializers）
C++ 14 支持 lambda capture initializers。比如：
// 按值捕获 target，但是在 Lambda 内部的变量名叫做 v
auto cnt =
std::count_if(books.begin(), books.end(), [v = target](const Book& book) {
return book.title.find(v) != std::string::npos;
});
// 按引用捕获 target，但是在 Lambda 内部的名字叫做 r
auto cnt =
std::count_if(books.begin(), books.end(), [&r = target](const Book& book) {
return book.title.find(r) != std::string::npos;
});
```
Lambda 捕获列表初始化最最最重要的一点是“支持 Capture by Move”。在 C++14 之前，Lambda 是不支持捕获一个 Move-Only 的对象的，比如：
std::unique_ptr uptr = std::make_unique(123);
auto callback = uptr { // 编译错误，uptr is move-only
std::cout << *uptr << std::endl;
};
按引用捕获虽然可以编译通过，但往往是不符合要求的。比如下面的例子，离开作用域之后 uptr 会被析构掉。但是 callback 对象已经被传给另一个线程。
std::unique_ptr uptr = std::make_unique(123);
auto callback = &uptr {
std::cout << *uptr << std::endl;
};
// … 将 callback 传给另一个线程
// return => uptr delete 掉指向的内存
通过捕获列表初始化，完成 Move-Only 对象的“Capture by Move”。
std::unique_ptr<int> uptr = std::make_unique<int>(123);
auto callback = [uptr = std::move(uptr)]() { // 将 uptr 移动给 Lambda 表达式中的参数
std::cout << *uptr << std::endl;
};
// ... 将 callback 传给另一个线程
// return => uptr 是 nullptr
通过捕获列表初始化，我们还可以捕获一个指针“Capture by Pointer”。
auto cnt =
std::count_if(books.begin(), books.end(), [p = &target](const Book& book) {
return book.title.find(*p) != std::string::npos;
});
[p = &target] 表示捕获 target 的指针，命名为 p。
Default Capture
Lambda 表示支持两种 default capture 的模式：
[=] 表示 default capture by value。按值捕获可见范围内的所有局部变量。
[&] 表示 default capture by reference。按引用捕获可见范围内的所有局部变量。
比如：
int a = 1;
std::string s = “hello”;
std::vector v;
auto default_capture_by_value = = {
// 按值捕获了 a、s 和 v
};
auto default_capture_by_reference = & {
// 按引用捕获了 a、s 和 v
};
不建议直接使用 [&] 或 [=] 捕获所有参数，而是按需显示捕获。
按值捕获的类型是 const 的。
int i = 100;
auto func = i {
i = 200; // 编译错误：assignment of read-only variable ‘i’
};
如果要修改按值捕获的参数，需要将 Lambda 表达式声明为 mutable 的。
int i = 100;
auto func = i mutable {
i = 200;
};
捕获 this 指针 在成员函数中的 Lambda 表达式可以捕获当前对象的 this 指针，让 Lambda 表达式拥有和当前类成员同样的访问权限，可以修改类的成员变量，使用类的成员函数。
class Foo {
public:
Foo(const std::string& s, int i) : s_(s), i_(i) {}
void Print() {
auto do_print = this{
std::cout << s_ << std::endl;
std::cout << i_ << std::endl;
};
do_print();
}
void Update(const std::string& s, int i) {
auto do_update = this, &s, i{
s_ = s;
i_ = i;
};
do_update();
}
private:
std::string s_;
int i_;
};
最后，this 指针只能按值捕获 [this] ，不能按引用捕获 [&this] 。