如何在C++回调函数中检查类的this指针是否有效？

你代码里的核心问题是：异步任务未完成时myClass对象已被销毁，导致回调里的this指向无效内存。这里有几个实用的解决思路：

1. 用std::enable_shared_from_this捕获对象的shared_ptr #

让myClass继承std::enable_shared_from_this<myClass>，在lambda里捕获shared_from_this()返回的智能指针。这样只要异步任务没结束，对象就会被智能指针持有，不会被提前销毁。

修改后的代码示例：

#include <memory>
#include <functional>
#include <thread>
#include <chrono>

// 模拟异步执行的函数
void async_do(std::function<void(int)> callback) {
    std::thread([callback](){
        std::this_thread::sleep_for(std::chrono::seconds(1));
        callback(5);
    }).detach();
}

class myClass : public std::enable_shared_from_this<myClass>
{
public:
    void fun()
    {
         async_do( [self = shared_from_this()](int j) {
             self->i += j;
         } );
    }

private:
    int i=9;
};

int main()
{
    std::shared_ptr<myClass> obj = std::make_shared<myClass>();
    obj->fun();
    obj.reset();
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 0;
}

注意：不能在构造函数里调用shared_from_this()，此时对象还未被shared_ptr接管。

2. 用std::weak_ptr捕获，回调前检查对象存活 #

如果不想强制延长对象生命周期（希望对象该销毁就销毁，回调直接跳过），可以捕获weak_ptr，回调时先通过lock()转换成shared_ptr，转换失败则说明对象已销毁，直接终止回调逻辑。

代码示例：

class myClass : public std::enable_shared_from_this<myClass>
{
public:
    void fun()
    {
         std::weak_ptr<myClass> weak_self = shared_from_this();
         async_do( [weak_self](int j) {
             if (auto self = weak_self.lock()) {
                 self->i += j;
             } else {
                 // 对象已销毁，直接返回
                 return;
             }
         } );
    }

private:
    int i=9;
};

这种方式更灵活，既避免了悬空指针，又不会不必要地占用对象资源。

3. 给异步任务增加取消机制 #

如果async_do框架支持取消操作，可以在对象析构时主动取消未完成的异步任务，从根源上阻止无效回调触发。比如：

class myClass
{
public:
    void fun()
    {
         // 假设async_do返回可取消的任务句柄
         task_handle = async_do( [this](int j) {
             i += j;
         } );
    }

    ~myClass() {
        if (task_handle.valid()) {
            task_handle.cancel();
        }
    }

private:
    int i=9;
    AsyncTaskHandle task_handle; // 假设的异步任务句柄类型
};

这种方法依赖异步框架的取消能力，能彻底避免无效回调。

4. 原子标志标记对象存活状态（简单场景可用） #

如果不想用智能指针，可以在类里加一个原子布尔变量标记对象是否存活，回调时先检查标志再执行操作：

#include <atomic>

class myClass
{
public:
    myClass() : alive(true) {}
    ~myClass() { alive.store(false); }

    void fun()
    {
         async_do( [this](int j) {
             if (alive.load()) {
                 i += j;
             }
         } );
    }

private:
    int i=9;
    std::atomic<bool> alive;
};

注意：这种方法存在竞态风险（检查标志和访问成员之间对象可能被销毁），仅适合逻辑简单的场景。

内容的提问来源于stack exchange，提问作者Ryan