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高——明确且安全

基本示例 ​

cpp
#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 没有被废弃

编译器支持情况 ​

特性GCCClangMSVC
[*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]。