捕获子句与按值捕获
在上一课 (20.6 -- Lambda 表达式(匿名函数)简介),我们介绍了这个示例:
#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>
int main()
{
std::array<std::string_view, 4> arr{ "apple", "banana", "walnut", "lemon" };
auto found{ std::find_if(arr.begin(), arr.end(),
[](std::string_view str)
{
return str.find("nut") != std::string_view::npos;
}) };
if (found == arr.end())
{
std::cout << "No nuts\n";
}
else
{
std::cout << "找到 " << *found << '\n';
}
return 0;
}
现在修改坚果示例,让用户选择要搜索的子字符串。 这并不像想象中那么直观。
#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>
#include <string>
int main()
{
std::array<std::string_view, 4> arr{ "apple", "banana", "walnut", "lemon" };
// 询问用户要搜索的内容。
std::cout << "search for: ";
std::string search{};
std::cin >> search;
auto found{ std::find_if(arr.begin(), arr.end(), [](std::string_view str) {
// 搜索 @search,而不是 "nut"。
return str.find(search) != std::string_view::npos; // 错误:在此作用域中无法访问 search
}) };
if (found == arr.end())
{
std::cout << "未找到\n";
}
else
{
std::cout << "找到 " << *found << '\n';
}
return 0;
}
这段代码无法编译。 与嵌套代码块不同,外层代码块中可访问的任何标识符在嵌套块中也可访问;lambda 只能访问在其外部定义的某些对象。 包括:
- 具有静态(或线程局部)存储期的对象(包括全局变量和静态局部变量)
- 显式或隐式声明为 constexpr 的对象
由于 search 不满足这些要求,lambda 无法看到它。
提示
lambda 只能访问在其外部定义的特定对象,包括具有静态存储期的对象(例如全局变量和静态局部变量)以及 constexpr 对象。
要在 lambda 内访问 search,需要使用捕获子句。
捕获子句
捕获子句用于(间接地)让 lambda 访问通常无法访问的外围作用域变量。我们只需将希望在 lambda 中访问的实体列入捕获子句即可。本例中,我们希望让 lambda 访问变量 search 的值,因此将它加入捕获子句:
#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>
#include <string>
int main()
{
std::array<std::string_view, 4> arr{ "apple", "banana", "walnut", "lemon" };
std::cout << "search for: ";
std::string search{};
std::cin >> search;
// 捕获 @search vvvvvv
auto found{ std::find_if(arr.begin(), arr.end(), [search](std::string_view str) {
return str.find(search) != std::string_view::npos;
}) };
if (found == arr.end())
{
std::cout << "未找到\n";
}
else
{
std::cout << "找到 " << *found << '\n';
}
return 0;
}
现在用户可以搜索数组中的元素。
输出
search for: nana
找到 banana
捕获实际上如何工作?
虽然上面的示例看起来像是 lambda 直接访问了 main 中的 search 变量,但实际并非如此。 Lambda 看起来像嵌套代码块,但工作方式略有不同(这种区别很重要)。
执行 lambda 定义时,对于 lambda 捕获的每个变量,都会在 lambda 内部创建该变量的副本(名称相同)。 这些克隆变量会在此时用外围作用域中同名变量的值进行初始化。
因此在上面的示例中,创建 lambda 对象时,lambda 会获得一个名为 search 的克隆变量。这个克隆的 search 与 main 中的 search 值相同,所以看起来像是在访问 main 的 search,但实际上并不是。
虽然这些副本名称相同,但它们的类型不一定与原变量相同。 我们将在本课后续章节中详细讨论这一点。
关键要点
lambda 捕获的变量是 外围作用域变量的副本,而不是变量本身。
进阶读者
虽然 lambda 看起来像函数,但实际上是可以像函数一样调用的对象 (这类参数称为 函子——我们将在后续课程中讨论如何从零开始创建自己的函子).
编译器遇到 lambda 定义时,会为它创建一个自定义对象定义。 每个捕获的变量都会成为该对象的数据成员。
运行时遇到 lambda 定义时,会实例化 lambda 对象,并在此时初始化 lambda 的成员。
捕获默认按 const 处理
调用 lambda 时, operator() 会被调用。默认情况下,这个 operator() 将捕获的变量视为 const,也就是说 lambda 不允许修改这些捕获变量。
在下面的示例中,我们捕获变量 ammo 并尝试将它递减。
#include <iostream>
int main()
{
int ammo{ 10 };
// 定义一个 lambda,并将其存储在名为 "shoot" 的变量中。
auto shoot{
[ammo]() {
// 非法:不能修改 ammo。
--ammo;
std::cout << "砰! " << ammo << " 发子弹剩余.\n";
}
};
// 调用 lambda
shoot();
std::cout << ammo << " 发子弹剩余\n";
return 0;
}
上面的代码无法编译,因为 ammo 在 lambda 内会被视为 const。
可变捕获
要允许修改捕获的变量,可以将 lambda 标记为 mutable:
#include <iostream>
int main()
{
int ammo{ 10 };
auto shoot{
[ammo]() mutable { // 现在可变
// 现在允许修改 ammo
--ammo;
std::cout << "砰! " << ammo << " 发子弹剩余.\n";
}
};
shoot();
shoot();
std::cout << ammo << " 发子弹剩余\n";
return 0;
}
输出:
砰! 9 发子弹剩余.
砰! 8 发子弹剩余.
10 发子弹剩余
虽然现在可以编译了,但仍然存在逻辑错误。 发生了什么? 调用 lambda 时,lambda 捕获了一个 ammo 的副本。当 lambda 将 ammo 从 10 递减到 9 再到 8 时,递减的是自己的副本,而不是 main() 中原始的 ammo 值。
请注意,ammo 的值会在多次调用 lambda 之间保留!
警告
由于捕获变量是 lambda 对象的成员,它们的值会在多次调用 lambda 之间保留!
按引用捕获
与函数可以修改按引用传递的实参类似,也可以按引用捕获变量,从而让 lambda 影响该实参的值。
要按引用捕获变量,需要在捕获列表中的变量名前加上和号(&)。与按值捕获的变量不同,按引用捕获的变量不是 const,除非被捕获的变量本身是 const。当你通常会选择按引用将实参传给函数时(例如非基本类型),也应优先使用按引用捕获。
下面是按引用捕获 ammo 后的代码:
#include <iostream>
int main()
{
int ammo{ 10 };
auto shoot{
// 不再需要 mutable
[&ammo]() { // &ammo 表示按引用捕获 ammo
// 对 ammo 的修改会影响 main 中的 ammo
--ammo;
std::cout << "砰! " << ammo << " 发子弹剩余.\n";
}
};
shoot();
std::cout << ammo << " 发子弹剩余\n";
return 0;
}
这会产生预期结果:
砰! 9 发子弹剩余.
9 发子弹剩余
现在使用引用捕获来统计 std::sort 排序数组时进行的比较次数。
#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>
struct Car
{
std::string_view make{};
std::string_view model{};
};
int main()
{
std::array<Car, 3> cars{ { { "Volkswagen", "Golf" },
{ "Toyota", "Corolla" },
{ "Honda", "Civic" } } };
int comparisons{ 0 };
std::sort(cars.begin(), cars.end(),
// 按引用捕获 @comparisons。
[&comparisons](const auto& a, const auto& b) {
// comparisons 按引用捕获,因此无需使用 "mutable" 也能修改它。
++comparisons;
// 按汽车品牌排序。
return a.make < b.make;
});
std::cout << "比较结果: " << comparisons << '\n';
for (const auto& car : cars)
{
std::cout << car.make << ' ' << car.model << '\n';
}
return 0;
}
可能的输出
比较结果: 2
Honda Civic
Toyota Corolla
Volkswagen Golf
捕获多个变量
可以用逗号分隔来捕获多个变量。 其中可以混合按值捕获和按引用捕获的变量:
int health{ 33 };
int armor{ 100 };
std::vector<CEnemy> enemies{};
// 按值捕获 health 和 armor,按引用捕获 enemies。
[health, armor, &enemies](){};
默认捕获
必须显式列出要捕获的变量可能很麻烦。修改 lambda 时,可能会忘记添加或删除捕获的变量。幸运的是,可以让编译器自动生成需要捕获的变量列表。
默认捕获(也称为捕获默认值)会捕获 lambda 中提到的所有变量。使用默认捕获时,lambda 中未提到的变量不会被捕获。
要按值捕获所有使用的变量,使用捕获符号 =。
要按引用捕获所有使用的变量,使用捕获符号 &。
下面是按值默认捕获的示例:
#include <algorithm>
#include <array>
#include <iostream>
int main()
{
std::array areas{ 100, 25, 121, 40, 56 };
int width{};
int height{};
std::cout << "Enter width and height: ";
std::cin >> width >> height;
auto found{ std::find_if(areas.begin(), areas.end(),
[=](int knownArea) { // 默认按值捕获 width 和 height
return width * height == knownArea; // 因为它们在这里被使用
}) };
if (found == areas.end())
{
std::cout << "I don't know this area :(\n";
}
else
{
std::cout << "找到区域 :)\n";
}
return 0;
}
默认捕获可以与普通捕获混用。可以按值捕获一些变量、按引用捕获另一些变量,但每个变量只能捕获一次。
int health{ 33 };
int armor{ 100 };
std::vector<CEnemy> enemies{};
// 按值捕获 health 和 armor,按引用捕获 enemies。
[health, armor, &enemies](){};
// 按引用捕获 enemies,其他变量全部按值捕获。
[=, &enemies](){};
// 按值捕获 armor,其他变量全部按引用捕获。
[&, armor](){};
// 非法:已经声明要按引用捕获所有变量。
[&, &armor](){};
// 非法:已经声明要按值捕获所有变量。
[=, armor](){};
// 非法:armor 出现了两次。
[armor, &health, &armor](){};
// 非法:默认捕获必须是捕获组中的第一个元素。
[armor, &](){};
在 lambda 捕获列表中定义新变量
有时我们希望先对捕获的变量做一些处理,或声明一个只在 lambda 作用域内可见的新变量。可以在 lambda 捕获列表中定义变量,而无需指定其类型。
#include <array>
#include <iostream>
#include <algorithm>
int main()
{
std::array areas{ 100, 25, 121, 40, 56 };
int width{};
int height{};
std::cout << "Enter width and height: ";
std::cin >> width >> height;
// 我们存储的是面积,但用户输入的是宽度和高度。
// 搜索之前需要先计算面积。
auto found{ std::find_if(areas.begin(), areas.end(),
// 声明一个仅在 lambda 中可见的新变量。
// userArea 的类型会自动推导为 int。
[userArea{ width * height }](int knownArea) {
return userArea == knownArea;
}) };
if (found == areas.end())
{
std::cout << "I don't know this area :(\n";
}
else
{
std::cout << "找到区域 :)\n";
}
return 0;
}
userArea 只会在定义 lambda 时计算一次。计算出的面积会存储在 lambda 对象中,每次调用时都相同。如果 lambda 是可变的,并修改了捕获列表中定义的变量,原始值就会被覆盖。
最佳实践
只有在捕获初始化器的值很短、类型很明显时,才建议直接在捕获列表中初始化变量;否则最好在 lambda 外部定义变量,再捕获它。
悬空的被捕获变量
变量会在定义 lambda 的位置被捕获。 如果按引用捕获的变量先于 lambda 销毁,lambda 就会持有悬空引用。
例如:
#include <iostream>
#include <string>
// 返回一个 lambda
auto makeWalrus(const std::string& name)
{
// 按引用捕获 name,并返回这个 lambda。
return [&]() {
std::cout << "I am a walrus, my name is " << name << '\n'; // 未定义行为
};
}
int main()
{
// 创建一个名为 Roofus 的新海象。
// sayName 是 makeWalrus 返回的 lambda。
auto sayName{ makeWalrus("Roofus") };
// 调用 makeWalrus 返回的 lambda。
sayName();
return 0;
}
调用 makeWalrus() 时,会根据字符串字面量 "Roofus" 创建一个临时 std::string。makeWalrus() 中的 lambda 按引用捕获这个临时字符串。包含 makeWalrus() 调用的完整表达式结束时,临时字符串就会销毁,但 lambda sayName 仍在此之后引用它。因此调用 sayName 时会访问悬空引用,从而产生未定义行为。
请注意,即使将 "Roofus" 按值传给 makeWalrus(),也会发生同样的问题。参数 name 会在 makeWalrus() 结束时销毁,而 lambda 留下了悬空引用。
警告
按引用捕获变量时要格外小心,使用默认引用捕获时尤其如此。被捕获变量的生命周期必须长于 lambda。
如果希望使用 lambda 时捕获的 name 仍然有效,就必须改为按值捕获它(可以显式捕获,也可以使用按值默认捕获)。
由于 lambda 是对象,因此可以被复制。在某些情况下,这会引发问题。请看下面的代码:
#include <iostream>
int main()
{
int i{ 0 };
// 创建名为 count 的新 lambda
auto count{ [i]() mutable {
std::cout << ++i << '\n';
} };
count(); // 调用 count
auto otherCount{ count }; // 创建 count 的副本
// 同时调用 count 和它的副本
count();
otherCount();
return 0;
}
输出
1
2
2
代码没有输出 1、2、3,而是输出了两次 2。 将 otherCount 创建为 count 的副本时,复制的是 count 当前的状态。count 的 i 为 1,因此 otherCount 的 i 也为 1。由于 otherCount 是 count 的副本,它们各自拥有独立的 i。
下面再看一个不太明显的示例:
#include <iostream>
#include <functional>
void myInvoke(const std::function<void()>& fn)
{
fn();
}
int main()
{
int i{ 0 };
// 递增并输出 @i 的局部副本。
auto count{ [i]() mutable {
std::cout << ++i << '\n';
} };
myInvoke(count);
myInvoke(count);
myInvoke(count);
return 0;
}
输出:
1
1
1
这以更隐蔽的形式出现了与前一个示例相同的问题。
调用 myInvoke(count) 时,编译器会发现 count(lambda 类型)与引用参数类型(std::function<void()>)不匹配。为了让引用参数能够绑定,编译器会把 lambda 转换为临时的 std::function,这会复制 lambda。因此,fn() 实际调用的是临时 std::function 中的 lambda 副本,而不是原来的 lambda。
如果需要传递可变 lambda,又想避免意外复制,有两种选择。一种是改用不捕获任何变量的 lambda——在上例中,可以移除捕获,改用静态局部变量保存状态。但静态局部变量不易跟踪,会降低代码可读性。更好的办法是从一开始就阻止 lambda 被复制。不过,我们无法改变 std::function(或其他标准库函数、对象)的实现,该怎么做呢?
一种方法(感谢读者 Dck 的建议)是立即将 lambda 放入 std::function。这样调用 myInvoke() 时,引用参数 fn 可以绑定到这个 std::function,不会创建临时副本:
#include <iostream>
#include <functional>
void myInvoke(const std::function<void()>& fn)
{
fn();
}
int main()
{
int i{ 0 };
// 递增并输出 @i 的局部副本。
std::function count{ [i]() mutable { // 将 lambda 对象存储在 std::function 中
std::cout << ++i << '\n';
} };
myInvoke(count); // 调用时不会创建副本
myInvoke(count); // 调用时不会创建副本
myInvoke(count); // 调用时不会创建副本
return 0;
}
现在的输出符合预期:
1
2
3
另一种方案是使用引用包装器。C++ 在 <functional> 头文件中提供了方便的 std::reference_wrapper 类型,让我们可以像传递引用一样传递普通类型。更方便的是,可以使用 std::ref() 函数创建 std::reference_wrapper。将 lambda 包装在 std::reference_wrapper 中后,任何复制 lambda 的操作实际复制的都是引用包装器,从而避免复制 lambda。
下面是使用 std::ref 的更新代码:
#include <iostream>
#include <functional> // 包含 std::reference_wrapper 和 std::ref
void myInvoke(const std::function<void()>& fn)
{
fn();
}
int main()
{
int i{ 0 };
// 递增并输出 @i 的局部副本。
auto count{ [i]() mutable {
std::cout << ++i << '\n';
} };
// std::ref(count) 确保将 count 当作引用处理
// 因此,任何试图复制 count 的操作实际上都会复制这个引用
// 确保始终只有一个 count
myInvoke(std::ref(count));
myInvoke(std::ref(count));
myInvoke(std::ref(count));
return 0;
}
现在的输出符合预期:
1
2
3
有趣的是,即使 myInvoke 按值接收 fn(而不是按引用),这种方法仍然有效!
规则
标准库函数可能会复制函数对象(提醒一下:lambda 就是函数对象)。如果要传递带有可变捕获变量的 lambda,请使用 std::ref 按引用传递。
最佳实践
尽量避免可变 lambda。不可变 lambda 更容易理解,不会遇到上述问题,也能避免加入并行执行后可能出现的更严重问题。
测验时间
问题 #1
下面哪些变量可以在 main 中被 lambda 使用,而无需显式捕获?
int i{};
static int j{};
int getValue()
{
return 0;
}
int main()
{
int a{};
constexpr int b{};
static int c{};
static constexpr int d{};
const int e{};
const int f{ getValue() };
static const int g{};
static const int h{ getValue() };
[](){
// 尝试使用这些变量,但不显式捕获它们。
a;
b;
c;
d;
e;
f;
g;
h;
i;
j;
}();
return 0;
}
显示解答
变量 无需显式捕获即可使用 a否。 a 具有自动存储期。b是。 b 可用于常量表达式。c是。 c 具有静态存储期。dYes. e是。 e 可用于常量表达式。f否。 f 的值取决于 getValue,可能需要运行程序才能确定。gYes. h是。 h 具有静态存储期。i是。 i 是全局变量。j是。 j 在整个文件中都可访问。
问题 #2
下面的代码会输出什么?不要运行代码,请在脑中推导。
#include <iostream>
#include <string>
int main()
{
std::string favoriteFruit{ "grapes" };
auto printFavoriteFruit{
[=]() {
std::cout << "我喜欢 " << favoriteFruit << '\n';
}
};
favoriteFruit = "bananas with chocolate";
printFavoriteFruit();
return 0;
}
显示解答
我喜欢 grapes
printFavoriteFruit 按值捕获了 favoriteFruit。修改 main 中的 favoriteFruit 不会影响 lambda 的 favoriteFruit。
问题 #3
我们来编写一个平方数小游戏(平方数是整数与自身相乘得到的数,例如 1、4、9、16、25……)。
游戏设置:
- 让用户输入起始数字(例如 3)。
- 让用户输入要生成多少个值。
- 随机选择一个 2 到 4 之间的整数,作为乘数。
- 生成用户指定数量的值。从起始数字开始,每个值都应是下一个平方数再乘以乘数。
游戏过程:
- 用户输入猜测值。
- 如果猜测值与某个生成值匹配,就从列表中移除该值,并让用户继续猜测。
- 如果用户猜中了所有生成值,就赢得游戏。
- 如果猜测与生成的值不匹配,用户输掉游戏,程序会告诉他最近的尚未猜出的值。
下面是几段示例运行过程,帮助你理解游戏的工作方式:
Start where? 4
How many? 5
I generated 5 square numbers. Do you know what each number is after multiplying it by 2?
> 32
Nice! 4 number(s) left.
> 72
Nice! 3 number(s) left.
> 50
Nice! 2 number(s) left.
> 126
126 is wrong! Try 128 next time.
- 从 4 开始,程序生成接下来的 5 个平方数: 16, 25, 36, 49, 64
- 程序随机选择 2 作为乘数,因此每个平方数都乘以 2: 32, 50, 72, 98, 128
- 现在轮到用户猜测。
- 32 在列表中。
- 72 在列表中。
- 126 不在列表中,因此用户输了。最近的未猜数字是 128。
Start where? 1
How many? 3
I generated 3 square numbers. Do you know what each number is after multiplying it by 4?
> 4
Nice! 2 number(s) left.
> 16
Nice! 1 number(s) left.
> 36
Nice! You found all numbers, good job!
- 从 1 开始,程序生成接下来的 3 个平方数: 1, 4, 9
- 程序随机选择 4 作为乘数,因此每个平方数都乘以 4: 4, 16, 36
- 用户猜中了所有数字,赢得了游戏。
提示:
- 使用 Random.h(8.15 -- 全局随机数(Random.h)))生成随机数。
- Use
std::find()(18.3 -- 标准库算法简介))搜索列表中的数字。 - 使用
std::vector::erase()删除元素,例如:
auto found{ std::find(/* ... */) };
// 确认找到了该元素
myVector.erase(found);
- 使用
std::min_element和 lambda 查找最接近用户猜测值的数字。std::min_element的工作方式类似于上一道测验中介绍的std::max_element。
显示提示
<cmath> 中的 std::abs 计算两个数字之间的正差值。int distance{ std::abs(3 - 5) }; // 2
显示解答
#include <algorithm> // std::find、std::min_element
#include <cmath> // std::abs
#include <cstddef> // std::size_t
#include <iostream>
#include <vector>
#include "Random.h"
using Numbers = std::vector<int>;
namespace config
{
constexpr int multiplierMin{ 2 };
constexpr int multiplierMax{ 6 };
}
// 生成 @count 个从 @start*@start 开始的数字,并将
// 每个平方数乘以 @multiplier。
Numbers generateNumbers(int start, int count, int multiplier)
{
Numbers numbers(static_cast<std::size_t>(count));
for (int index = 0; index < count; ++index)
{
std::size_t uindex{ static_cast<std::size_t>(index) };
numbers[uindex] = (start + index) * (start + index) * multiplier;
}
return numbers;
}
// 询问用户输入起始数字,然后生成数字数组
Numbers setupGame()
{
int start{};
std::cout << "Start where? ";
std::cin >> start;
int count{};
std::cout << "How many? ";
std::cin >> count;
int multiplier{ Random::get(config::multiplierMin, config::multiplierMax) };
std::cout << "I generated " << count
<< " square numbers. Do you know what each number is after multiplying it by "
<< multiplier << "?\n";
return generateNumbers(start, count, multiplier);
}
// 返回用户的猜测值
int getUserGuess()
{
int guess{};
std::cout << "> ";
std::cin >> guess;
return guess;
}
// 在 @numbers 中查找 @guess,并将其删除。
// 找到该值时返回 true,否则返回 false。
bool findAndRemove(Numbers& numbers, int guess)
{
auto found{ std::find(numbers.begin(), numbers.end(), guess) };
if (found == numbers.end())
return false;
numbers.erase(found);
return true;
}
// 查找 @numbers 中最接近 @guess 的值。
int findClosestNumber(const Numbers& numbers, int guess)
{
return *std::min_element(numbers.begin(), numbers.end(),
[=](int a, int b)
{
return std::abs(a - guess) < std::abs(b - guess);
});
}
// 用户猜对数字时调用。
void printSuccess(const Numbers& numbers)
{
std::cout << "Nice! ";
if (numbers.size() == 0)
{
std::cout << "You found all numbers, good job!\n";
}
else
{
std::cout << numbers.size() << " number(s) left.\n";
}
}
// 用户猜测的数字不在列表中时调用。
void printFailure(const Numbers& numbers, int guess)
{
int closest{ findClosestNumber(numbers, guess) };
std::cout << guess << " is wrong!\n";
std::cout << "Try " << closest << " next time.\n";
}
int main()
{
Numbers numbers{ setupGame() };
while (true)
{
int guess{ getUserGuess() };
if (!findAndRemove(numbers, guess))
{
printFailure(numbers, guess);
break;
}
printSuccess(numbers);
if (numbers.size() == 0)
break;
}
return 0;
}