C++ Lambda 表达式

参考文章：C++ 11 Lambda表达式

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

声明 lambda 表达式

lambda 表达式完整的声明格式和各项具体含义如下：

声明格式：
[capture list] (params list) mutable exception-> return type { function body }

其中除了 "[]" (其中捕获列表可以为空) 和 “复合语句” (相当于具名函数定义的函数体) ，其它都是可选的。
它的类型是单一的具有成员 operator() 的非联合的类类型，称为闭包类型 (closure type) 。

各项的具体含义：
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： 省略了 mutable 指示符，这种类型的表达式不能修改捕获列表中的值；
表达式 2： 在 1 的基础上省略了返回值，但编译器可以根据以下规则推断出 Lambda 表达式的返回类型：
(1)：如果 function body 中存在 return 语句，则该 Lambda 表达式的返回类型由 return 语句的返回类型确定；
(2)：如果 function body 中没有 return 语句，则返回值为 void 类型。
表达式 3： 在 2 的基础上省略了参数列表，类似普通函数中的无参函数。

简单例子熟悉 Lambda 表达式：

std::vector<int> v1 = {5, 3, 9, 1, 2, 0, 4, 6, 8, 7};
std::vector<int> v2 = v1;

PRINT_INFO("v1 before sort:");
ShowVectorInfo(v1);

//回调函数compar
sort(v1.begin(), v1.end(), compar);

PRINT_INFO("v1 after sort:");
ShowVectorInfo(v1);

PRINT_INFO("v2 before sort:");
ShowVectorInfo(v2);

//c++11 lambda
sort(v2.begin(), v2.end(), [](int a, int b) -> bool { return a < b; }); //传入匿名函数

PRINT_INFO("v2 after sort:");
ShowVectorInfo(v2);

输出：

[INFO]: v1 before sort:
5 3 9 1 2 0 4 6 8 7 
[INFO]: v1 after sort:
0 1 2 3 4 5 6 7 8 9 
[INFO]: v2 before sort:
5 3 9 1 2 0 4 6 8 7 
[INFO]: v2 after sort:
0 1 2 3 4 5 6 7 8 9 

捕获外部变量 ( [] )

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

int a = 555;

//捕获外部变量 a
auto func1 = [a] { PRINT_INFO("a = " << a); };
func1(); //[INFO]: a = 555

//通过“函数体”后面的‘()’传入参数
[] (int a) { PRINT_INFO("a = " << a); }(a); //[INFO]: a = 555

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

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

主要形式如下：

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

值捕获

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

int a = 555;

//打印变量 a 的值和地址
PRINT_INFO("a = " << a << ", &a = " << &a);

//值捕获
auto func1 = [a] { PRINT_INFO("[a] : a = " << a << ", &a = " << &a); };
func1(); //a = 555
a = 444;
func1(); //a = 555

//auto func2 = [a] { PRINT_INFO("a = " << ++a); }; //error: increment of read-only variable ‘a’

输出：

[INFO]: a = 555, &a = 0x7fff46ed09fc
[INFO]: [a] : a = 555, &a = 0x7fff46ed09f0
[INFO]: [a] : a = 555, &a = 0x7fff46ed09f0

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

引用捕获

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

int a = 555;

//打印变量 a 的值和地址
PRINT_INFO("a = " << a << ", &a = " << &a);
//引用捕获
auto func2 = [&a] { PRINT_INFO("[&a] : a =  " << a << ", &a = " << &a); };
func2(); //[INFO]: a = 444
a = 333;
func2(); //[INFO]: a = 333

输出：

[INFO]: a = 555, &a = 0x7fffd6ade214
[INFO]: [&a] : a =  555, &a = 0x7fffd6ade214
[INFO]: [&a] : a =  333, &a = 0x7fffd6ade214

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

隐式捕获

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

隐式值捕获：

int b = 222;
int c = 111;
auto func3 = [=] { PRINT_INFO("b = " << b << ", c = " << c); };
func3(); //[INFO]: b = 222, c = 111
b = 1;
c = 2;
func3(); //[INFO]: b = 222, c = 111

隐式引用捕获：

int b = 222;
int c = 111;
auto func4 = [&] { PRINT_INFO("b = " << b << ", c = " << c); };
func4(); //[INFO]: b = 222, c = 111
b = 1;
c = 2;
func4(); //[INFO]: b = 1, c = 2

混合方式

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

//混合方式
int a = 555;
int b = 444;
int c = 333;

//变量 b 值捕获，其他变量引用捕获
auto func1 = [&, b]() { PRINT_INFO("a = " << a << ",b = " << b << ",c = " << c); };
func1(); //[INFO]: a = 555,b = 444,c = 333

//变量 b 引用捕获，其他变量值捕获
auto func2 = [=, &b]() { PRINT_INFO("a = " << a << ",b = " << b << ",c = " << c); };
func2(); //[INFO]: a = 555,b = 444,c = 333

//变量 b 引用捕获，变量 a 值捕获
auto func3 = [a, &b]() { PRINT_INFO("a = " << a << ",b = " << b); };
func3(); //[INFO]: a = 555,b = 444

//[=, &] error: expected identifier before ‘]’ token
//auto func4 = [=, &]() { PRINT_INFO("a = " << a << ",b = " << b << ",c = " << c); };

捕获 this 指针

class test_lambda
{
public:
    void show()
    {
        PRINT_INFO("test_lambda::show()");
    }

    void lambda()
    {
        auto func = [this] { 
            PRINT_INFO_NO_END("Call test_lambda::show(): ");
            this->show(); };

        func();
    }
};

test_lambda tl;
tl.lambda(); //[INFO]: Call test_lambda::show(): [INFO]: test_lambda::show()

修改捕获变量 ( mutable )

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

//mutable
auto func5 = [a]() mutable { PRINT_INFO("a = " << ++a); };
func5(); //[INFO]: a = 556
PRINT_INFO("outside a = " << a); //[INFO]: outside a = 555

参数列表 ( params list )

Lambda表达式的参数和普通函数的参数类似；以下形式也支持：

//默认参数
auto func6 = [](int a, int b = 0) { PRINT_INFO("a = " << a << ",b = " << b); };
func6(1);

//无名参数
auto func7 = [](int a, int ) { PRINT_INFO("a = " << a); };
func7(1, 2);

//可变参数
auto func8 = [](int a, ...) { PRINT_INFO("a = " << a); };
func8(2);

输出：

[INFO]: a = 1,b = 0
[INFO]: a = 1
[INFO]: a = 2

Note

//lambda 嵌套
int m = [](int x) { return [](int y){ return y * 2; }(x) + 6; }(5);
PRINT_INFO("m = " << m); //[INFO]: m = 16

//lambda 嵌套捕获
auto func9 = [](int x) -> std::function<int (int)> { return [=](int y) { return x + y; }; };
auto func10 = func9(5);
PRINT_INFO("func10(3) : " << func10(3)); //[INFO]: func10 : 8

//lambda 参数为函数指针
auto func11 = [](const std::function<int (int)> &f, int z) { return f(z) + 1; };
PRINT_INFO("func11(func9(5), 3)) : " << func11(func9(5), 3)); //[INFO]: func11(func9(5), 3)) : 9

//lambda 修改引用捕获
PRINT_INFO("outside a = " << a << ",b = " << b);
auto func12 = [a, &b]() { b = 0; PRINT_INFO("[a, &b]: " << a << ",b = " << b); };
func12();
//[INFO]: outside a = 555,b = 444 
//[INFO]: [a, &b]: 555,b = 0

//lambda 修改值捕获
auto func13 = [a, &b]() mutable { a = 0; b = 1; PRINT_INFO("[a, &b] mutable: " << a << ",b = " << b); };
func13(); //[INFO]: [a, &b] mutable: 0,b = 1

输出：

[INFO]: m = 16
[INFO]: func10(3) : 8
[INFO]: func11(func9(5), 3)) : 9
[INFO]: outside a = 555,b = 444
[INFO]: [a, &b]: 555,b = 0
[INFO]: [a, &b] mutable: 0,b = 1

Lambda 使用场景：在你的整个项目编程中，你独立出来一个函数，但这个函数实现相对简单并且可能在整个项目只使用了一次(即不存在复用的情况)，那么这个时候我们就可以考虑使用下 lambda 表达式了，这样可以让代码更加紧凑，更加容易维护。