Lambda 捕获 this 改进
背景
在 C++20 之前,[=] 默认捕获会隐式捕获 this 指针(按指针值捕获),这容易让人误以为是按值捕获了成员变量。实际上,[=] 捕获的是 this 指针的副本,通过它访问的成员变量仍然是原始对象的成员——如果原始对象被销毁,lambda 中的成员访问就是悬空引用。
C++17 引入了 [*this] 语法,允许按值捕获整个对象(拷贝一份)。C++20 则正式废弃了 [=] 隐式捕获 this 的行为,要求显式写出 this 或 *this。
捕获 this 的三种方式
| 捕获语法 | 含义 | 引入版本 | 安全性 |
|---|---|---|---|
[this] | 捕获 this 指针(指针拷贝) | C++11 | 低——对象销毁后悬空 |
[*this] | 按值捕获整个对象(拷贝对象) | C++17 | 高——lambda 持有独立副本 |
[=] 隐式捕获 this | 等价于 [this](C++20 废弃) | C++11(C++20 废弃) | 低——容易误解 |
[=, this] | 默认按值 + 显式捕获 this 指针 | C++20 | 明确意图 |
[=, *this] | 默认按值 + 按值捕获对象 | C++17 | 高——明确且安全 |
基本示例
#include <iostream>
#include <functional>
#include <string>
#include <vector>
#include <memory>
// ============================
// 示例1:[=] 隐式捕获 this 的问题
// ============================
struct Widget {
int value = 42;
auto get_lambda_old() {
// C++20 之前:[=] 隐式捕获 this 指针
// C++20 中这会产生废弃警告
// 看上去像是按值捕获 value,实际上是捕获了 this 指针
return [=] {
return value; // 实际上是 this->value
};
}
auto get_lambda_explicit_this() {
// C++20 推荐:显式捕获 this
return [=, this] {
return value; // 明确知道是通过 this 访问
};
}
auto get_lambda_copy() {
// C++17/20:按值捕获整个对象
return [*this] {
return value; // 访问的是副本的 value
};
}
};
void basic_demo() {
std::function<int()> fn;
{
Widget w;
w.value = 100;
// 按值捕获对象——安全
fn = w.get_lambda_copy();
}
// w 已销毁,但 lambda 持有 w 的副本
std::cout << "副本的值: " << fn() << std::endl; // 100,安全
}
// ============================
// 示例2:悬空 this 的危险
// ============================
struct Timer {
std::string name;
int interval_ms;
// 危险:捕获 this 指针,如果 Timer 对象被销毁,callback 中访问成员是未定义行为
auto make_dangerous_callback() {
return [this] {
// 如果 Timer 对象已被销毁,this 是悬空指针
std::cout << name << " 触发, 间隔 " << interval_ms << "ms" << std::endl;
};
}
// 安全:按值捕获整个对象
auto make_safe_callback() {
return [*this] {
// 使用的是 Timer 的副本,不依赖原始对象的生命周期
std::cout << name << " 触发, 间隔 " << interval_ms << "ms" << std::endl;
};
}
};
void dangling_demo() {
std::function<void()> callback;
{
Timer t{"定时器A", 1000};
callback = t.make_safe_callback(); // 安全:拷贝了整个 Timer
}
// Timer 已销毁
callback(); // 安全调用
}
// ============================
// 示例3:[=, this] vs [=, *this]
// ============================
struct Processor {
std::string id = "CPU-1";
int task_count = 0;
void process(int data) {
int local_data = data * 2; // 局部变量
// [=, this]:局部变量按值捕获,this 按指针捕获
auto fn1 = [=, this] {
// local_data 是副本(安全)
// id 和 task_count 通过 this 访问(依赖对象存活)
std::cout << id << " 处理数据: " << local_data << std::endl;
};
// [=, *this]:局部变量按值捕获,对象也按值捕获
auto fn2 = [=, *this] {
// local_data 是副本
// id 和 task_count 也是副本(完全独立)
std::cout << id << " 处理数据: " << local_data << std::endl;
};
fn1();
fn2();
}
};
// ============================
// 示例4:异步场景下的正确捕获
// ============================
struct AsyncTask {
std::string task_name;
int priority;
// 返回一个可以安全在异步上下文中执行的回调
auto create_async_handler() {
// 按值捕获对象——即使 AsyncTask 被销毁,回调仍然安全
return [*this]() mutable {
// 操作的是副本的成员
priority++;
std::cout << "异步执行: " << task_name
<< " 优先级: " << priority << std::endl;
};
}
};
void async_demo() {
std::vector<std::function<void()>> tasks;
{
AsyncTask t1{"下载文件", 5};
AsyncTask t2{"解析数据", 3};
tasks.push_back(t1.create_async_handler());
tasks.push_back(t2.create_async_handler());
}
// t1 和 t2 已销毁
// 安全执行所有异步任务
for (auto& task : tasks) {
task();
}
}
// ============================
// 示例5:选择 [this] 还是 [*this]
// ============================
struct Logger {
std::string prefix;
int log_count = 0;
// 需要修改原始对象状态时,用 [this]
auto make_counter_lambda() {
return [this] {
log_count++; // 修改原始对象的 log_count
std::cout << prefix << " 日志计数: " << log_count << std::endl;
};
}
// 不需要修改原始对象、或对象可能被销毁时,用 [*this]
auto make_snapshot_lambda() {
return [*this] {
// log_count 是快照值,不会改变原始对象
std::cout << prefix << " 快照计数: " << log_count << std::endl;
};
}
};
void choice_demo() {
Logger logger{"[APP]", 0};
auto counter = logger.make_counter_lambda();
auto snapshot = logger.make_snapshot_lambda();
counter(); // log_count 变为 1
counter(); // log_count 变为 2
snapshot(); // 快照值仍为 0
std::cout << "原始 log_count: " << logger.log_count << std::endl; // 2
}
int main() {
std::cout << "=== 基本用法 ===" << std::endl;
basic_demo();
std::cout << "\n=== 悬空 this ===" << std::endl;
dangling_demo();
std::cout << "\n=== 异步场景 ===" << std::endl;
async_demo();
std::cout << "\n=== 选择策略 ===" << std::endl;
choice_demo();
return 0;
}如何选择捕获方式
| 场景 | 推荐捕获方式 | 原因 |
|---|---|---|
| lambda 在成员函数内同步使用 | [this] | 对象不会被销毁,且可能需要修改成员 |
| lambda 存储到容器或回调中 | [*this] | 对象可能在 lambda 执行前被销毁 |
| 异步/多线程传递 lambda | [*this] | 对象生命周期不可控 |
| 需要修改原始对象的成员 | [this] | *this 是副本,修改不影响原对象 |
| 同时需要局部变量按值 + this | [=, this] 或 [=, *this] | 明确意图 |
适用场景
- 异步回调中避免悬空 this 指针
- 将 lambda 存储到
std::function或容器中 - 多线程环境下安全传递成员函数的逻辑
- 需要对象状态快照的场景
- 从 C++17 之前的代码迁移,消除
[=]隐式捕获 this 的废弃警告
常见问题
[=] 在 C++20 中还能捕获 this 吗?
能,但会产生废弃警告。[=] 隐式捕获 this 的行为还没有被移除,只是被废弃了。建议改为 [=, this] 或 [=, *this]。
*[this] 捕获会触发拷贝构造吗?
会。[*this] 会调用对象的拷贝构造函数创建一个副本。如果对象拷贝开销很大,需要考虑性能影响。
*[this] 捕获的副本可以修改吗?
默认不可以(lambda 的 operator() 是 const 的)。加上 mutable 就可以修改副本的成员,但不影响原始对象。
[this] 和 [&] 有什么区别?
[this] 只捕获 this 指针。[&] 是默认引用捕获,也会隐式捕获 this 指针(这个行为在 C++20 中没有被废弃)。
注意事项
- C++20 废弃了
[=]隐式捕获 this,改用[=, this]或[=, *this] [*this]会拷贝整个对象,注意性能开销[*this]的副本在 lambda 内部默认是 const 的,需要mutable才能修改[this]捕获的是指针,对象销毁后访问成员是未定义行为[&]隐式捕获 this 没有被废弃
编译器支持情况
| 特性 | GCC | Clang | MSVC |
|---|---|---|---|
[*this](C++17) | 7.0+ | 3.9+ | 19.11+ |
[=, this](C++20) | 8.0+ | 6.0+ | 19.22+ |
[=] 捕获 this 废弃警告 | 10.0+ | 10.0+ | 19.22+ |
总结
C++20 废弃了 [=] 隐式捕获 this 指针的行为,要求显式写 [=, this](捕获指针)或 [=, *this](拷贝对象)。这个改变解决了一个长期的困惑:[=] 看上去是"全部按值捕获",但 this 实际上是按指针捕获的,通过它访问的成员变量并不是副本。在异步回调、多线程、或 lambda 生命周期超过对象生命周期的场景中,应该用 [*this] 按值捕获对象来避免悬空指针。在同步场景下如果需要修改原始对象的成员,仍然用 [this]。