C11Lambda表达式

C++ 11 Lambda表达式

C++11的一大亮点就是引入了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表达式的返回类型： （1）：如果function body中存在return语句，则该Lambda表达式的返回类型由return语句的返回类型确定；（2）：如果function body中没有return语句，则返回值为void类型。
格式3中省略了参数列表，类似普通函数中的无参函数。

基本例子

在C++11之前，我们使用STL的sort函数，需要提供一个谓词函数。如果使用C++11的Lambda表达式，我们只需要传入一个匿名函数即可，方便简洁，而且代码的可读性也比旧式的做法好多了。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

bool cmp(int a, int b)
{
    return  a < b;
}

int main()
{
    vector<int> myvec{ 3, 2, 5, 7, 3, 2 };
    vector<int> lbvec(myvec);

    sort(myvec.begin(), myvec.end(), cmp); // 旧式做法
    cout << "predicate function:" << endl;
    for (int it : myvec)
        cout << it << ' ';
    cout << endl;

    sort(lbvec.begin(), lbvec.end(), [](int a, int b) -> bool { return a < b; });   // Lambda表达式
    cout << "lambda expression:" << endl;
    for (int it : lbvec)
        cout << it << ' ';
}

捕获外部变量

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); 
}

上面这个例子对比了使用捕获变量和参数传递的方式两种用法。第一个捕获了外部的变量a，可以在匿名函数中直接使用，第二个，则是在调用函数x的时候，通过()传递的123给匿名函数的入口参数，和前面申明的a没有任何关系。

值捕获

顾名思义，就是直接捕获外部变量的值，在申明匿名函数的时候捕获到值后，如果该变量值被修改，然后再调用匿名函数，那么匿名函数使用的值还是原先的值，这就是值捕获的特定，只是在捕获的那一刻对值进行了拷贝，类似于函数值传递的特点一样。如下例子。值捕获的变量，在函数内部不能修改该外部变量的值，会出发编译错误

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

引用捕获

使用引用捕获一个外部变量，只需要在捕获列表变量前面加上一个引用说明符。同理，引用捕获的变量使用的实际上就是该引用所绑定的对象，因此随后对被捕获变量的修改会影响影响Lambda表达式中的值。（可以修改外部变量）

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

隐式捕获

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

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

混合方式

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

修改捕获变量的值

又想用值捕获，又想用值捕获的方式，就需要使用mutable关键字，该关键字用以说明表达式体内的代码可以修改值捕获的变量。(引用捕获就可以修改外部变量的值，mutable方式可能是针对指针变量使用的吧)

int main()
{
    int a = 123;
    auto f = [a]()mutable { cout << ++a; }; // 不会报错
    cout << a << endl; // 输出：123
    f(); // 输出：124
}

Lambda表达式的参数

Lambda表达式的参数和普通函数的参数类似，单是在Lambda表达式中传递参数还有一些限制，主要有以下几点：

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

Ruowang's blogs

C++Lambda表达式