我们可以向一个算法传递任何类别的可调用对象(callable object)。对于一个对象或个表达式,如果可以对其使用调用运算符,则称它为可调用的。即,如果 e 是一个可调用的表达式,则我们可以编写代码 e(args),其中 args 是一个逗号分隔的一个或多个参数的列表。
C++ 中可调用对象有函数、函数指针、重载了函数调用运算符的类,以及 lambda 表达式(lambda expression)。
一个 lambda 表达式表示一个可调用的代码单元。我们可以将其理解为一个未命名的内联函数。与任何函数类似,一个 lambda 具有一个返回类型、一个参数列表和一个函数体。但与函数不同, lambda 可能定义在函数内部。一个 lambda 表达式具有如下形式:
[capture list](parameter list)-> return type { function body }
其中,capture list(捕获列表)是一个 lambda 所在函数中定义的局部变量的列表(通常为空); return type、parameter list 和 function body 与任何普通函数一样,分别表示返回类型、参数列表和函数体。但是,与普通函数不同,lambda 必须使用尾置返回来指定返回类型。
我们可以忽略参数列表和返回类型,但必须永远包含捕获列表和函数体:
auto f = [] {return 42;}
上面的例子中,我们定义了一个可调用对象 f,它不接受参数,返回 42。
lambda 的调用方式与普通函数的调用方式相同,都是使用调用运算符:
cout << f() << endl; // 打印 42
在 lambda 中忽略括号和参数列表等价于指定一个空参数列表。在此例中,当调用 f 时,参数列表是空的。如果忽略返回类型,lambda 根据函数体中的代码推断出返回类型。如果函数体只是一个 return 语句,则返回类型从返回的表达式的类型推断而来。否则,返回类型为 void。
注意:如果 lambda 的函数体包含任何单一 return 语句之外的内容,且未指定返回类型,则返回 void。
向 lambda 传递参数
与一个普通函数调用类似,调用一个 lambda 时给定的实参被用来初始化 lambda 的形参。通常,实参和形参的类型必须匹配。但与普通函数不同,lambda 不能有默认参数。因此,一个 lambda 调用的实参数目永远与形参数目相等。一旦形参初始化完毕,就可以执行函数体了。
一个带参数的 lambda 的例子:
[](const string &a, const string &b) {
return a.size() < b.size();
}
空捕获列表表明此 lambda 不使用它所在函数中的任何局部变量。
如下所示,可以使用此 lambda 来调用 stable_sort:
// 按长度排序,长度相同的单词维持字典序
stable_sort(words.begin(), words.end(),
[](const string &a, const string &b) { return a.size() < b.size();});
当 stable_sort 需要比较两个元素时,它就会调用给定的这个 lambda 表达式。
使用捕获列表
虽然一个 lambda 可以出现在一个函数中,使用其局部变量,但它只能使用那些明确指明的变量。一个 lambda 通过将局部变量包含在其捕获列表中来指出将会使用这些变量。捕获列表指引 lambda 在其内部包含访问局部变量所需的信息。
在本例中,我们的 lambda 会捕获 sz,并只有单一的 string 参数。其函数体会将 string 的大小与捕获的 sz 的值进行比较:
[sz](const string &a)
{ return a.size() >= sz; };
lambda 以一对 [] 开始,我们可以在其中提供一个以逗号分隔的名字列表,这些名字都是它所在函数中定义的。
由于此 lambda 捕获 sz,因此 lambda 的函数体可以使用 sz。lambda 不捕获 words 因此不能访问此变量。如果我们给 lambda 提供一个空捕获列表,则代码会编译错误:
// 错误:sz 未捕获
[](const string &a) { return a.size() >= sz; };
注意:一个 lambda 只有在其捕获列表中捕获一个它所在函数中的局部变量,才能在函数体中使用该变量。
lambda 捕获和返回
当定义一个 lambda 时,编译器生成一个与 lambda 对应的新的(未命名的)类类型。我们可以这样理解,当向一个函数传递一个 lambda 时,同时定义了一个新类型和该类型的一个对象:传递的参数就是此编译器生成的类类型的未命名对象。类似的,当使用 auto 定义一个用 lambda 初始化的变量时,定义了一个从 lambda 生成的类型的对象。
默认情况下,从 lambda 生成的类都包含一个对应该 lambda 所捕获的变量的数据成员。类似任何普通类的数据成员,lambda 的数据成员也在 lambda 对象创建时被初始化。
值捕获
类似参数传递,变量的捕获方式也可以是值或引用。到目前为止,我们的 lambda 采用值捕获的方式。与传值参数类似,采用值捕获的前提是变量可以拷贝。与参数不同,被捕获的变量的值是在 lambda 创建时拷贝,而不是调用时拷贝:
void fcn1() {
size_t v1 = 42;//局部变量
// 将 v1 拷贝到名为 f 的可调用对象
auto f = [v1] { return v1; };
v1 = 0;
auto j = f2(); // j 为 42; f 保存了我们创建它时 v1 的拷贝
}
由于被捕获变量的值是在 lambda 创建时拷贝,因此随后对其修改不会影响到 lambda 内对应的值。
引用捕获
我们定义 lambda 时可以采用引用方式捕获变量。例如:
void fcn2 () {
size_t v1 = 42; // 局部变量
// 对象 f2 包含 v1 的引用
auto f2 = [&v1] { return v1; };
v1 = 0;
auto 3 = f2(); // j 为 0; f2 保存 v1 的引用,而非拷贝
}
v1 之前的 & 指出 v1 应该以引用方式捕获。一个以引用方式捕获的变量与其他任何类型的引用的行为类似。当我们在 lambda 函数体内使用此变量时,实际上使用的是引用所绑定的对象。在本例中,当 lambda 返回 v1 时,它返回的是 v1 指向的对象的值。
引用捕获与返回引用有着相同的问题和限制。如果我们采用引用方式捕获一个变量,就必须确保被引用的对象在 lambda 执行的时候是存在的。lambda 捕获的都是局部变量,这些变量在函数结束后就不复存在了。如果 lambda 可能在函数结束后执行,捕获的引用指向的局部变量已经消失。
引用捕获有时是必要的。例如,我们可能希望 biggies 函数接受一个 ostream 的引用,用来输出数据,并接受一个字符作为分隔符:
void biggies(vector<string> &words,
vector<string>::size_type sz,
ostream &os = cout, char c = ' ') {
for_each(words.begin(), words.end(), [&os, c](const string &s) { os << s << c; });
}
我们不能拷贝 ostream 对象,因此捕获 os 的唯一方法就是捕获其引用(或指向 os 的指针)。
当我们向一个函数传递一个 lambda 时,就像本例中调用 for_each 那样 lambda 会立即执行。在此情况下,以引用方式捕获 os 没有问题,因为当 for_each 执行时,biggies 中的变量是存在的。
我们也可以从一个函数返回 lambda。函数可以直接返回一个可调用对象,或者返回一个类对象,该类含有可调用对象的数据成员。如果函数返回一个 lambda,则与函数不能返回一个局部变量的引用类似,此 lambda 也不能包含引用捕获。
建议:尽量保持 lambda 的变量捕获简单化
一个 lambda 捕获从 lambda 被创建(即,定义 lambda 的代码执行时 ) 到
lambda 自身执行(可能有多次执行)这段时间内保存的相关信息。确保
lambda 每次执行的时候这些信息都有预期的意义,是程序员的责任。
捕获一个普通变量,如 int、string 或其他非指针类型,通常可以采用简单的值
捕获方式。在此情况下,只需关注变量在捕获时是否有我们所需的值就可以了。
如果我们捕获一个指针或迭代器,或采用引用捕获方式,就必须确保在
lambda 执行时,绑定到迭代器,指针或引用的对象仍然存在。而且,需要保
证对象具有预期的值。在 lambda 从创建到它执行的这段时间内,可能有代码
改变绑定的对象的值。也就是说,在指针(或引用)被捕获的时刻,绑定的对
象的值是我们所期望的,但在 lambda 执行时,该对象的值可能已经完全不同了。
一般来说,我们应读尽量减少捕获的数据量,来避免潜在的捕获导致的问题。
而且,如果可能的话,应试避免捕获指针或引用。
隐式捕获
除了显式列出我们希望使用的来自所在函数的变量之外,还可以让编译器根据 lambda 体中的代码来推断我们要使用哪些变量。为了指示编译器推断捕获列表,应在捕获列表中写一个 & 或 =。& 告诉编译器采用捕获引用方式,= 则表示采用值捕获方式。例如,我们可以重写传递给 find_if 的 lambda:
// sz 为隐式捕获,值捕获方式
wc = find_if(words.begin(), words.end(),
[=](const string &s){ return s.size() >= sz;});
如果我们希望对一部分变量釆用值捕获,对其他变量采用引用捕获,可以混合使用隐式捕获和显式捕获:
void biggies(vector<string> &words, vector<string>::size_type sz,
ostream &os = cout, char c = ' ') {
// 其他处理
// os 隐式捕获,引用捕获方式;c 显式捕获,值捕获方式
for_each(words.begin(), words.end(), [&, c](const string &s) { os << s << c;});
// os 显式捕获,引用捕获方式;c 隐式捕获,值捕获方式
for_each(words.begin(), words.end(), [=, &os](const string &s) { os << s << c;});
}
当我们混合使用隐式捕获和显式捕获时,捕获列表中的第一个元素必须是一个 & 或 =。此符号指定了默认捕获方式为引用或值。
当混合使用隐式捕获和显式捕获时,显式捕获的变量必须使用与隐式捕获不同的方式。即,如果隐式捕获是引用方式(使用 &),则显式捕获命名变量必须采取值方式,因此不能在其名字前使用 &。类似地,如果隐式捕获采用的是值方式(使用 = ),则显式捕获命名变量必须采用引用方式,即,在名字前使用 &。
lambda 捕获列表 | 说明 |
---|---|
[] | 空捕获列表。lambda 不能使用所在函数中的变量。一个 lambda 只有捕获变量后才能使用它们 |
[names] | names是一个逗号分隔的名字列表,这些名字都是 lambda 所在函数的局部变量。默认情况下,捕获列表中的变量都被拷贝。名字前如果使用了 &,则采用引用捕获方式 |
[&] | 隐式捕获列表,采用引用捕获方式。lambda 体中所使用的来自所在函数的实体都采用引用方式使用 |
[=] | 隐式捕获列表,采用值捕获方式。lambda 体将拷贝所使用的来自所在函数的实体的值 |
[&,identifier_list] | identifier_list 是一个逗号分隔的列表,包含 0 个或多个来自所在函数的变量。这些变量都采用值捕获方式,而任何隐式捕获的变量都采用引用方式捕获。identifier_list 中的名字前面不能使用 & |
[=,identifier_list] | identifier_list 中的变量都采用引用方式捕获,而任何隐式捕获的变量都采用值方式捕获。identifier_list 中的名字不能包括 this,且这些名字之前必须使用 & |
可变 lambda
默认情况下,对于一个值被拷贝的变量,lambda 不会改变其值。如果我们希望能改变一个被捕获的变量的值,就必须在参数列表首加上关键字 mutable。因此,可变 lambda 能省略参数列表:
void fcn3() {
size_t v1 = 42; // 局部变量
// f 可以改变它所捕获的变量的值
auto f = [v1]() mutable { return ++v1; };
v1 = 0;
auto j = f(); // j 为 43
}
一个引用捕获的变量是否(如往常一样)可以修改依赖于此引用指向的是一个 const 类型还是一个非 const 类型:
void fcn4() {
size_t v1 = 42; // 局部变量
// v1 是一个非 const 变量的引用
// 可以通过 f2 中的引用来改变它
auto f2 = [&v1]() mutable { return ++v1; };
v1 = 0;
auto j = f2(); // j 为 1
}
指定 lambda 返回类型
到目前为止,我们所编写的 lambda 都只包含单一的 return 语句。因此,我们还未遇到必须指定返回类型的情况。默认情况下,如果一个 lambda 体包含 return 之外的任何语句,则编译器假定此 lambda 返回 void。与其他返回 void的函数类似,被推断返回 void 的 lambda 不能返回值。
下面给出了一个简单的例子,我们可以使用标准库 transform 算法和一个 lambda 来将一个序列中的每个负数替换为其绝对值:
transform(vi.begin(), vi.end(), vi.begin(),
[](int i) { return i < 0 ? -i : i; });
函数 transform 接受三个迭代器和一个可调用对象。前两个迭代器表示输入序列,第三个迭代器表示目的位置。算法对输入序列中每个元素调用可调用对象,并将结果写到目的位置。如本例所示,目的位置迭代器与表示输入序列开始位置的迭代器可以是相同的。当输入迭代器和目的迭代器相同时,transform 将输入序列中每个元素替换为可调用对象操作该元素得到的结果。
在本例中,我们传递给 transform 一个 lambda,它返回其参数的绝对值。 lambda 体是单一的 return 语句,返回一个条件表达式的结果。我们无须指定返回类型,因为可以根据条件运算符的类型推断出来。
但是,如果我们将程序改写为看起来是等价的 if 语句,就会产生编译错误:
// 错误:不能推断 lambda的返回类型
transform(vi.begin(), vi.end(), vi.begin(),
[](int i) { if(i < 0) return -i; else return i; });
编译器推断这个版本的 lambda 返回类型为 void,但它返回了一个 int 值。
当我们需要为一个 lambda 定义返回类型时,必须使用尾置返回类型:
transform(vi.begin(), vi.end(), vi.begin(),
[](int i) -> int { if(i < 0) return -i; else return i; });
在此例中,传递给 transform 的第四个参数是一个 lambda,它的捕获列表是空的,接受单一 int 参数,返回一个 int 值。它的函数体是一个返回其参数的绝对值的 if 语句。
网友评论