说明如下：


* capture：捕获作用域内变量，后面详述
* params：参数
* mutable：可变的，用来说明可以修改捕获的变量
* exception：异常
* return type：返回类型
* function body：函数体


一个简单的Lambda类似下面：

// 返回值类型通过自动推导获得
auto foo = [](int x) { return x + 1; };

std::cout << foo(2) << std::endl; // 输出：3

##### 捕获外部变量




---


Lambda需要明确声明需要使用哪些范围内可见变量，否则无法使用。规则如下：


* [] 不捕获任何变量。
* [&] 捕获外部作用域中所有变量，并作为引用在函数体中使用（按引用捕获）。
* [=] 捕获外部作用域中所有变量，并作为副本在函数体中使用（按值捕获）。
* [=，&foo] 按值捕获外部作用域中所有变量，并按引用捕获 foo 变量。
* [&, x]：默认以引用捕获所有变量，但是x是例外，通过值捕获。
* [bar] 按值捕获 bar 变量，同时不捕获其他变量。
* [this] 捕获当前类中的 this 指针，让 lambda 表达式拥有和当前类成员函数同样的访问权限。如果已经使用了 & 或者 =，就默认添加此选项。捕获 this 的目的是可以在 lamda 中使用当前类的成员函数和成员变量。
* [\*this]：通过传值方式捕获当前对象。


举例如下：

class A
{
public:
int i_ = 0;
void func(int x, int y)
{
auto x1 = []{ return i_; }; // error，没有捕获外部变量
auto x2 = [=]{ return i_ + x + y; }; // OK，捕获所有外部变量
auto x3 = [&]{ return i_ + x + y; }; // OK，捕获所有外部变量
auto x4 = [this]{ return i_; }; // OK，捕获this指针
auto x5 = [this]{ return i_ + x + y; }; // error，没有捕获x、y
auto x6 = [this, x, y]{ return i_ + x + y; }; // OK，捕获this指针、x、y
auto x7 = [this]{ return i_++; }; // OK，捕获this指针，并修改成员的值
}
};

int a = 0, b = 1;
auto f1 = []{ return a; }; // error，没有捕获外部变量
auto f2 = [&]{ return a++; }; // OK，捕获所有外部变量，并对a执行自加运算
auto f3 = [=]{ return a; }; // OK，捕获所有外部变量，并返回a
auto f4 = [=]{ return a++; }; // error，a是以复制方式捕获的，无法修改
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 表达式的类型在 C++11 中被称为“闭包类型（Closure Type）”。因此，我们可以认为它是一个带有 operator() 的类，即仿函数。因此，我们可以使用 std::function 和 std::bind 来存储和操作 lambda 表达式：

std::function<int(int)> f1 = [](int a){ return a; };
std::function<int(int)> f2 = std::bind([](int a){ return a; }, 123);

这里也可以很自然地解释为何按值捕获无法修改捕获的外部变量。因为按照 C++ 标准，lambda 表达式的 operator() 默认是 const 的。一个 const 成员函数是无法修改成员变量的值的。而 mutable 的作用，就在于取消 operator() 的 const。


把Lambda作为就地定义使用的函数极其方便，如下代码统计std::vector中数据：

std::vector v = { 1, 2, 3, 4, 5, 6 };
int even_count = 0;
for_each( v.begin(), v.end(), [&even_count](int val)
{
if (!(val & 1)) // val % 2 == 0
{
++ even_count;
}
});
std::cout << "The number of even is " << even_count << std::endl;

而在c11之前，则需要专门定义一个函数用来做统计。


作为回调函数也很简单，如使用cpp\_redis库连接redis时，选择数据库的代码：

// 不使用Lambda
void RedisSelectCb(cpp_redis::reply &reply)
{
if (reply.is_error())
{
std::cout << "err: " << reply << std::endl;
}
}

// …

m_redis->select(2, boost::bind(&RedisSelectCb, _1));
m_redis->sync_commit();

// 使用Lambda
m_redis->select(2, [](cpp_redis::reply &reply) {
if (reply.is_error())
{
std::cout << "err: " << reply << std::endl;
}
});
m_redis->sync_commit();

lambda 表达式的价值在于，就地封装短小的功能闭包，可以极其方便地表达出我们希望执行的具体操作，并让上下文结合得更加紧密。


##### 注意事项




---


* 一般情况下，编译器就会根据 return 语句自动推导出返回值类型，但初始化列表不能用于返回值的自动推导，如 `auto x2 = [](){ return { 1, 2 }; }; // error: 无法推导出返回值类型`
* lambda 表达式是延迟调用的，如下代码：

int a = 0;
auto f = [=]{ return a; }; // 按值捕获外部变量
a += 1; // a被修改了
std::cout << f() << std::endl; // 输出: 0

捕获的一瞬间，a 的值就已经被复制到f中了。之后 a 被修改，但此时 f 中存储的 a 仍然还是捕获时的值，如果希望 lambda 表达式在调用时能够即时访问外部变量，我们应当使用引用方式捕获。


* 默认状态下 lambda 表达式无法修改通过复制方式捕获的外部变量，如果需要修改，需要显式指明 lambda 表达式为 mutable，如下：

int a = 0;
auto f1 = [=]{ return a++; }; // error，修改按值捕获的外部变量
auto f2 = = mutable { return a++; }; // OK，mutable

需要注意的一点是，被 mutable 修饰的 lambda 表达式就算没有参数也要写明参数列表。


当然，在Lambda使用中，也会有一些坑，查看[深入理解c++中的Lambda表达式](https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0) 了解如何避开坑。


###### 参考资料




---