Lambda函数的语法定义如下:
[capture](parameters) mutable ->return-type{statement}
其中:
- [capture]:捕捉列表。捕捉列表总是出现在 lambda 表达式的开始处。事实上,[] 是 lambda 引出符。编译器根据该引出符判断接下来的代码是否是 lambda 函数。捕捉列表能够捕捉上下文中的变量供 lambda 函数使用。
- []:默认不捕获任何变量;
- [=]:默认以值捕获所有变量;
- [&]:默认以引用捕获所有变量;
- [x]:仅以值捕获x,其它变量不捕获;
- [&x]:仅以引用捕获x,其它变量不捕获;
- [=, &x]:默认以值捕获所有变量,但是x是例外,通过引用捕获;
- [&, x]:默认以引用捕获所有变量,但是x是例外,通过值捕获;
- [this]:通过引用捕获当前对象(其实是复制指针);
- [*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函数中使用,这就决定了我们必须要考虑到可能存在的异步操作