Lambda 函数与表达式

Lambda函数的语法定义如下：

[capture](parameters) mutable ->return-type{statement}

其中：

•  [capture]：捕捉列表。捕捉列表总是出现在 lambda 表达式的开始处。事实上，[] 是 lambda 引出符。编译器根据该引出符判断接下来的代码是否是 lambda 函数。捕捉列表能够捕捉上下文中的变量供 lambda 函数使用。

1. []：默认不捕获任何变量；
2. [=]：默认以值捕获所有变量；
3. [&]：默认以引用捕获所有变量；
4. [x]：仅以值捕获x，其它变量不捕获；
5. [&x]：仅以引用捕获x，其它变量不捕获；
6. [=, &x]：默认以值捕获所有变量，但是x是例外，通过引用捕获；
7. [&, x]：默认以引用捕获所有变量，但是x是例外，通过值捕获；
8. [this]：通过引用捕获当前对象（其实是复制指针）；
9. [*this]：通过传值方式捕获当前对象；

•  (parameters)：参数列表。与普通函数的参数列表一致。如果不需要参数传递，则可以连同括号 () 一起省略。
•  mutable：mutable 修饰符。默认情况下，lambda 函数总是一个 const 函数，mutable 可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）。
•  ->return_type：返回类型。用追踪返回类型形式声明函数的返回类型。出于方便，不需要返回值的时候也可以连同符号 -> 一起省略。此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导。
•  {statement}：函数体。内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量。

在 lambda 函数的定义式中，参数列表和返回类型都是可选部分，而捕捉列表和函数体都可能为空，C++ 中最简单的 lambda 函数只需要声明为：

[]{};

举例说明：

定义一个可以输出字符串的lambda表达式，表达式一般都是从方括号[]开始，然后结束于花括号{}，花括号里面就像定义函数那样，包含了lamdba表达式体：

// 定义简单的lambda表达式
auto basicLambda = [] { cout << "Hello, world!" << endl; };

// 调用
basicLambda();
// 输出：Hello, world!

如果需要参数，那么就要像函数那样，放在圆括号里面，如果有返回值，返回类型要放在->后面，即拖尾返回类型，当然你也可以忽略返回类型，lambda会帮你自动推断出返回类型：

// 指明返回类型
auto add = [](int a, int b) -> int { return a + b; };

// 自动推断返回类型
auto multiply = [](int a, int b) { return a * b; };
int sum = add(2, 5);   // 输出：7
int product = multiply(2, 5);  // 输出：10

规则说明：

1、什么也不捕获，或者是故意不用 Lambda 函数外部的变量

#include <iostream>
using namespace std;
 
int main()
{
    int i = 1024;
    auto func = [] { cout << i; };
    func();
}  // 结果报错，因为未指定默认捕获模式

正确的如下：

#include <iostream>
using namespace std;
 
int main()
{
    int i = 1024;
    auto func = [=]{  // [=] 表明将外部的所有变量拷贝一份到该Lambda函数内部
        cout << i;
    };
    func();
}

2、引用捕获

#include <iostream>
using namespace std;
 
int main()
{
    int i = 1024;
    cout << &i << endl;
    auto fun1 = [&]{
        cout << &i << endl;
    };
    fun1();
}

3、复制并引用捕获

#include <iostream>
using namespace std;
 
int main()
{
    int i = 1024, j = 2048;
 
    cout << "i:" << &i << endl;
    cout << "j:" << &j << endl;
 
    auto fun1 = [=, &i]{ // 默认拷贝外部所有变量，但引用变量 i
        cout << "i:" << &i << endl;
        cout << "j:" << &j << endl;
    };
    fun1();
}

4、指定引用或复制

#include <iostream>
using namespace std;
 
int main()
{
    int i = 1024, j = 2048;
 
    cout << "outside i value:" << i << " addr:" << &i << endl;
 
    auto fun1 = [i]{
        cout << "inside  i value:" << i << " addr:" << &i << endl;
        // cout << j << endl; // j 未捕获
    };
    fun1();
}

5、捕获this指针

#include <iostream>
using namespace std;
 
class test
{
public:
    void hello() {
        cout << "test hello!n";
    };
    void lambda() {
        auto fun = [this]{ // 捕获了 this 指针
            this->hello(); // 这里 this 调用的就是 class test 的对象了
        };
        fun();
    }
};
 
int main()
{
    test t;
    t.lambda();
}

常量性说明：

常量性区别1

#include <iostream>
using namespace std;

int main()
{
	int j = 12;
	auto by_val_lambda = [=] {return j + 1;}
	auto by_ref_lambda = [&] {return j + 1;}
	
	cout << "by_val_lambda:" << by_val_bambda() << endl;
	cout << "by_ref_lambda:" << by_ref_lambda() << endl;
	
	j++;
	cout << "by_val_lambda:" << by_val_lambda() << endl;
	cout << "by_ref_lambda:" << by_ref_lambda() << endl;
}

上述这段代码运行后得到的结果是：

by_val_lambda: 13
by_ref_lambda: 13
by_val_lambda: 13
by_ref_lambda: 14

之所以会出现上述结果是因为，对于按照值方式的捕捉列表，其传递的值在lambda函数定义的时候就已经决定了。而按照引用的方式捕捉的列表，其传递的值等于lambda函数调用时的值。因此，我们可以认为，值方式捕捉列表，其捕捉的值将是一个常量。

常量性区别2

前文已述，lambda函数默认是一个const函数，那么这种const特性主要体现在什么地方呢？看一看下述代码：
 

int main()
{
	int val;
	auto const_val_lambda = [=](){val = 3;}  //#1
	auto const_val_lambda = [=]()mutable {val = 3;}
	auto const_ref_lambda = [&]{val = 3;}
	auto const_param_lambda = [&](int v){v = 3;};
	const_param_lambda_lambda(val);
}

在上述各种形式的声明中，只有#1处的值方式捕获在修改捕获变量时会报错，而引用捕获则不会。

  这里目前先提出该结论，暂不解释原因，原因在后文中会提及。

lambda函数的实现

lambda函数到底是怎样实现的呢？事实上，仿函数是编译器实现lambda的一种方式，通常编译器都会把lambda函数转化成为一个仿函数对象，因此，lambda可以视为仿函数的一种等价形式。如下图所示：

从图中我们可以看到，lambda函数和仿函数都可以捕捉一些变量作为初始状态，并接受参数进行运算。

这也解释了上面所提及的常量性区别2的原因：因为当使用值方式捕获时，捕获量被等价为了仿函数中的一个私有成员，而根据const的特性，在const成员函数中，我们是不能改变成员数据的；而使用引用方式捕获，则不会改变引用本身，只会改变引用的值，因此编译器将编译通过。

如果我们还记的话，仿函数在STL的诸多算法中都有应用，而lambda函数本质又是基于仿函数实现的，这也决定lambda函数能够在STL中广泛应用。

注意事项

• lambda函数虽然基于仿函数实现，但无法完全等价于仿函数，主要原因在于其捕获区域限制在父作用域。
• 函数指针可以指向lambda函数，但是此时lambda函数必须无捕获值。
• lambda函数是一种局部封装，局部共享，如果要全局共享，还是需要使用仿函数或者普通函数。
• 以值方式捕获时，需要考虑到其拷贝成本，如果拷贝成本太大，建议使用引用方式。
• 捕获对象，既可以在父作用域使用，也可以在lambda函数中使用，这就决定了我们必须要考虑到可能存在的异步操作