C++ lambda 的那些坑
Posted on Sat 11 May 2024 in Journal
| Abstract | C++ lambda 的那些坑 |
|---|---|
| Authors | Walter Fan |
| Category | learning note |
| Status | v1.0 |
| Updated | 2024-05-11 |
| License | CC-BY-NC-ND 4.0 |
在 C++ 中，Lambda 表达式提供了一种简洁、灵活的方式来定义匿名函数对象（也被称为闭包或 lambda 表达式）。然而，像任何其他编程语言特性一样，Lambda 在使用时也存在一些需要注意的“坑”。下面我将列举一些在使用 C++ Lambda 时可能会遇到的问题和陷阱。
-
捕获列表的陷阱 Lambda 表达式的捕获列表用于捕获 Lambda 外部的变量以供在 Lambda 体内使用。捕获方式有值捕获（通过等号 =）和引用捕获（通过 &）。
-
值捕获的陷阱：如果捕获的变量在 Lambda 表达式被调用之前被修改，Lambda 体内将使用捕获时的值，而不是最新的值。
- 引用捕获的陷阱：如果捕获的变量在 Lambda 表达式生命周期结束后被销毁，但 Lambda 仍然被保存并稍后调用，这将导致悬垂引用（dangling reference）问题。
-
默认捕获的陷阱：使用默认捕获（[=] 或 [&]）时要特别小心，因为它会捕获所有外部可见的变量。这可能导致意外的捕获和不必要的性能开销。
-
Lambda 的返回值类型 Lambda 表达式的返回类型是由其返回语句自动推断的。如果 Lambda 体内有多个返回语句且它们的类型不同，这将导致编译错误。此外，如果 Lambda 没有返回语句，它的返回类型将被推断为 void。
-
Lambda 的生命周期 Lambda 表达式的生命周期与其创建时的上下文紧密相关。如果 Lambda 是在一个函数内部创建的，并且该函数返回了该 Lambda，那么必须确保 Lambda 的所有捕获的变量在 Lambda 的生命周期内都是有效的。
-
Lambda 与 std::function 的交互 std::function 是一个通用的、类型安全的函数包装器，它可以存储、复制和调用任何可调用的目标（如函数、Lambda 表达式、函数对象等）。然而，将 Lambda 存储在 std::function 中可能会引入额外的开销，因为 std::function 是一个动态类型的容器，它在运行时需要进行类型擦除和动态调度。
-
Lambda 的性能考虑 虽然 Lambda 表达式在语法上非常简洁和灵活，但它们可能会引入一些性能开销。这包括捕获变量的拷贝开销（对于值捕获）和引用捕获可能导致的悬垂引用问题。此外，如果 Lambda 被频繁地创建和销毁（例如在循环中），这可能会导致额外的内存分配和释放开销。
-
Lambda 的可读性和可维护性 虽然 Lambda 表达式可以提高代码的简洁性和可读性，但它们也可能使代码更难以理解和维护。特别是在复杂的代码中，嵌套过多的 Lambda 表达式可能会使代码结构变得混乱和难以跟踪。
-
Lambda 与模板的交互 当 Lambda 与模板一起使用时，可能会遇到一些复杂的问题。例如，Lambda 的类型在编译时是未知的（它是一个唯一的匿名类型），这可能会导致模板类型推断失败或产生意外的结果。此外，Lambda 的捕获列表和返回类型也可能与模板参数产生交互，导致复杂的类型匹配问题。
错误用法示例
例1: 悬挂引用
#include <iostream>
#include <functional>
std::function<void()> createLambda() {
int x = 10;
return [&]() {
std::cout << x << std::endl; // x is a dangling reference
};
}
int main() {
auto lambda = createLambda();
lambda(); // This will crash because x no longer exists
return 0;
}
正确的写法应该是
std::function<void()> createLambda() {
int x = 10;
return [x]() {
std::cout << x << std::endl; // x is captured by value
};
}
例 2: 捕捉不当的 this 指针
要确保 lambda 的寿命不会比 this 指针指向对象还长，或者按值捕获必要的数据。
#include <iostream>
#include <functional>
class MyClass {
public:
MyClass(int value) : value(value) {}
std::function<void()> createLambda() {
return [this]() {
std::cout << value << std::endl; // this might be a dangling pointer
};
}
private:
int value;
};
int main() {
std::function<void()> lambda;
{
MyClass obj(42);
lambda = obj.createLambda();
}
// obj is destroyed here
lambda(); // This will crash because `this` is a dangling pointer
return 0;
}
正确的写法是
int main() {
{
MyClass obj(42);
auto lambda = obj.createLambda();
lambda(); // Safe to call here
}
// obj is destroyed here, but lambda has already been called
return 0;
}
为减少出错机率, 还是写得笨点好
std::function<void()> createLambda() {
int localValue = value; // Capture the necessary data by value
return [localValue]() {
std::cout << localValue << std::endl;
};
}
例 3: 捕获方式的错误选择
在某些情况下，捕获方式选择错误会导致意想不到的行为或编译错误。特别是当捕获的对象是一个指针或复杂对象时。
示例：捕获指针后指针所指对象被销毁
#include <iostream>
#include <vector>
#include <algorithm>
void demo() {
std::vector<int> data = {1, 2, 3, 4, 5};
int* ptr = &data[0];
auto lambda = [ptr]() {
std::cout << *ptr << std::endl; // ptr 所指对象可能已被销毁
};
data.clear(); // data 被清空，ptr 成为悬挂指针
lambda(); // 可能导致未定义行为或崩溃
}
int main() {
demo();
return 0;
}
解决方法：
在捕获指针时，确保其生命周期不会在 lambda 使用前结束。或者避免捕获指针，改用更安全的捕获方式。
例 4. 隐式捕获导致的未定义行为
使用隐式捕获（如 [=] 或 [&]）可能会捕获到一些你并不希望捕获的变量，导致意外行为。
示例：
#include <iostream>
void demo() {
int x = 10;
auto lambda = [=]() {
std::cout << x << std::endl; // 隐式捕获 x，按值捕获
};
x = 20;
lambda(); // 输出 10，而不是 20
}
int main() {
demo();
return 0;
}
解决方法：
尽量避免使用隐式捕获，明确列出需要捕获的变量，确保代码的可读性和可维护性。
auto lambda = [x]() {
std::cout << x << std::endl;
};
例 5. 可变性 (mutable) 的误用
默认情况下，lambda 捕获的变量是常量（const）。如果需要修改捕获的变量，必须使用 mutable 关键字。如果误用了 mutable，可能导致意外的行为或难以调试的错误。
示例：
#include <iostream>
void demo() {
int x = 10;
auto lambda = [x]() mutable {
x = 20;
std::cout << x << std::endl; // 输出 20
};
lambda();
std::cout << x << std::endl; // 输出 10，x 并未被修改
}
int main() {
demo();
return 0;
}
- mutable 使得 lambda 内部可以修改捕获的变量副本。
- 外部的 x 并未被修改，这可能与预期不符。
解决方法：
理解 mutable 的用法及其影响，确保修改捕获变量副本是预期行为。如果需要修改外部变量，应捕获引用。
auto lambda = [&x]() {
x = 20;
std::cout << x << std::endl;
};
例 6. 捕获未初始化的变量
捕获未初始化的变量会导致未定义行为。这种错误有时不易察觉，特别是在复杂的代码中。
示例：
#include <iostream>
void demo() {
int x;
auto lambda = [&x]() {
std::cout << x << std::endl; // 未初始化的 x
};
lambda(); // 未定义行为
}
int main() {
demo();
return 0;
}
解决方法：
在捕获变量之前，确保其已正确初始化。
int x = 0; // 确保 x 已初始化
auto lambda = [&x]() {
std::cout << x << std::endl;
};
例 7. 捕获对象后修改其状态
如果捕获的是复杂对象（如类对象），在 lambda 内修改其状态可能导致不可预见的错误或状态不一致。
示例：
#include <iostream>
#include <vector>
void demo() {
std::vector<int> data = {1, 2, 3, 4, 5};
auto lambda = [data]() mutable {
data.push_back(6); // 修改捕获的副本，外部不可见
std::cout << data.size() << std::endl; // 输出 6
};
lambda();
std::cout << data.size() << std::endl; // 输出 5，外部未改变
}
int main() {
demo();
return 0;
}
解决方法：
根据需求选择合适的捕获方式，确保 lambda 内外状态一致。
auto lambda = [&data]() {
data.push_back(6); // 修改原始对象
std::cout << data.size() << std::endl;
};
总结
虽然 C++ 中的 Lambda 表达式是一个非常强大和有用的特性，但在使用时也需要谨慎处理上述提到的陷阱和问题。通过仔细考虑 Lambda 的捕获方式、返回类型、生命周期、性能开销以及与其他特性的交互方式，可以编写出更加健壮、高效和可维护的代码。
1) 避免使用默认的捕获模式 按引用的默认捕获模式可能导致空悬引用, 按值的默认捕获模式会好些, 但也不会完全避免空悬引用(例如指针的复制), 我们最好显式的列出 lambda 所依赖的局部变量或者形参
2) 使用初始化捕获将对象移入闭包
本作品采用知识共享署名-非商业性使用-禁止演绎 4.0 国际许可协议进行许可。