C++11 - Lambda 表达式 | Songkc's Blog | Talk is cheap, show me the code.

C++11 的一大亮点就是引入了 Lambda 表达式。利用 Lambda 表达式，可以方便的定义和创建匿名函数。

声明 Lambda 表达式

Lambda 表达式完整的声明格式如下：

1	[capture list] (params list) mutable exception-> return type { function body }

各项具体含义如下：

capture list：捕获外部变量列表
params list：形参列表
mutable：用来说用是否可以修改捕获的变量
exception：异常设定
return type：返回类型
function body：函数体

此外，我们还可以省略其中的某些成分来声明“不完整”的 Lambda 表达式，常见的有以下几种：

序号	格式
1	[capture list] (params list) -> return type { function body }
2	[capture list] (params list) { function body }
3	[capture list] { function body }

格式 1 声明了 const 类型的表达式，这种类型的表达式不能修改捕获列表中的值。
格式 2 省略了返回值类型，但编译器可以根据以下规则推断出 Lambda 表达式的返回类型：
- 如果 function body 中没有 return 语句，则返回值为 void 类型；
- 如果 function body 中存在 return 语句，则该 Lambda 表达式的返回类型由 return 语句的返回类型确定。
格式 3 中省略了参数列表，类似普通函数中的无参函数。

捕获外部变量

Lambda 表达式可以使用其可见范围内的外部变量，但必须明确声明（明确声明哪些外部变量可以被该 Lambda 表达式使用）。那么，在哪里指定这些外部变量呢？Lambda 表达式通过在最前面的方括号 [] 来明确指明其内部可以访问的外部变量，这一过程也称作 Lambda 表达式“捕获”了外部变量。

通过一个例子来直观地说明一下：

#include <iostream>
using namespace std;

int main()
{
    int a = 123;
    auto f = [a] { cout << a << endl; }; 
    f();  // 输出：123

    //或通过“函数体”后面的‘()’传入参数
    auto x = [](int a){ cout << a << endl; }(123); 
    return 0;
}

上面这个例子先声明了一个整型变量 a，然后再创建 Lambda 表达式，该表达式“捕获”了变量 a，这样在 Lambda 表达式函数体中就可以获得该变量的值。

类似参数传递方式（值传递、引入传递、指针传递），在Lambda表达式中，外部变量的捕获方式也有值捕获、引用捕获、隐式捕获。

值捕获

值捕获和参数传递中的值传递类似，被捕获的变量的值在 Lambda 表达式创建时通过值拷贝的方式传入，因此随后对该变量的修改不会影响影响 Lambda 表达式中的值。示例如下：

#include <iostream>
using namespace std;

int main()
{
    int a = 123;
    auto f = [a] { cout << a << endl; }; 
    a = 321;
    f();  // 输出：123
    return 0;
}

这里需要注意的是，如果以传值方式捕获外部变量，则在 Lambda 表达式函数体中不能修改该外部变量的值。

引用捕获

使用引用捕获一个外部变量，只需要在捕获列表变量前面加上一个引用说明符 &。如下：

#include <iostream>
using namespace std;

int main()
{
    int a = 123;
    auto f = [&a] { cout << a << endl; }; 
    a = 321;
    f();  // 输出：321
    return 0;
}

从示例中可以看出，引用捕获的变量使用的实际上就是该引用所绑定的对象。

隐式捕获

上面的值捕获和引用捕获都需要我们在捕获列表中显式列出 Lambda 表达式中使用的外部变量。除此之外，我们还可以让编译器根据函数体中的代码来推断需要捕获哪些变量，这种方式称之为隐式捕获。隐式捕获有两种方式，分别是 [=] 和 [&]。[=] 表示以值捕获的方式捕获外部变量，[&] 表示以引用捕获的方式捕获外部变量。

#include <iostream>
using namespace std;

int main()
{
    int a = 123;
    auto f = [=] { cout << a << endl; };      // 隐式值捕获
    a = 321;
    f();    // 输出：123

    int b = 123;
    auto func = [&] { cout << b << endl; };   // 隐式引用捕获
    b = 321;
    func();  // 输出：321
    return 0;
}

混合方式

上面的例子，要么是值捕获，要么是引用捕获，Lambda 表达式还支持混合的方式捕获外部变量，混合方式主要是以上几种捕获方式的组合使用。

总结一下，C++11 中的 Lambda 表达式捕获外部变量主要有以下形式：

捕获形式	说明
[]	不捕获任何外部变量
[变量名, …]	默认以值得形式捕获指定的多个外部变量（用逗号分隔），如果引用捕获，需要显示声明（使用&说明符）
[this]	以值的形式捕获this指针
[=]	以值的形式捕获所有外部变量
[&]	以引用形式捕获所有外部变量
[=, &x]	变量x以引用形式捕获，其余变量以传值形式捕获
[&, x]	变量x以值的形式捕获，其余变量以引用形式捕获

修改捕获变量

前面我们提到过，在 Lambda 表达式中，如果以传值方式捕获外部变量，则函数体中不能修改该外部变量，否则会引发编译错误。那么有没有办法可以修改值捕获的外部变量呢？这是就需要使用 mutable 关键字，该关键字用以说明表达式体内的代码可以修改值捕获的变量，示例：

#include <iostream>
using namespace std;

int main()
{
    int a = 123;
    auto f = [a]()mutable { cout << ++a; };  // OK
    cout << a << endl;  // 输出：123
    f();  // 输出：124
    return 0;
}

Lambda 表达式的参数

Lambda 表达式的参数和普通函数的参数类似，那么这里为什么还要拿出来说一下呢？原因是在 Lambda 表达式中传递参数还有一些限制，主要有以下几点：

参数列表中不能有默认参数
不支持可变参数
所有参数必须有参数名

C++11 - Lambda 表达式