调用外部函数可能销毁当前对象时，如何禁止后续访问成员变量？

这个问题我之前在项目里也碰到过，隐式自销毁的对象真的是调试噩梦——明明代码看起来没问题，却时不时出现奇怪的崩溃或者内存错误，而且很难复现。针对你遇到的场景，我整理了几个实用的解决方案，按优先级推荐：

1. 重构代码，让销毁逻辑显式化 #

这是最根本的解决办法，能从源头避免隐式销毁的坑。尽量不要让Bar::func2()直接销毁调用它的Foo对象，而是改成通知Foo自行处理销毁的方式：

void Foo::func() {
    Bar b;
    // 让func2返回是否需要销毁当前Foo对象
    bool need_destroy = b.func2();
    
    if (need_destroy) {
        // 显式销毁自己，逻辑清晰可见
        delete this;
        return;
    }
    
    // 这里可以安全访问Foo的成员，因为确定对象还活着
    this->some_member = 42;
}

这种方式把销毁逻辑放在Foo自己的控制范围内，任何人看代码都能一眼明白“调用func2后可能会销毁当前对象”，完全消除了隐式性。

2. 用弱指针跟踪自身生命周期 #

如果重构代码不可行（比如依赖第三方库或者历史代码），可以用std::enable_shared_from_this结合弱指针来确保调用后的对象有效性：

#include <memory>

class Foo : public std::enable_shared_from_this<Foo> {
public:
    void func() {
        // 先获取自身的弱指针
        auto self_weak = weak_from_this();
        
        Bar b;
        b.func2();
        
        // 尝试锁定弱指针，如果对象已销毁，lock()会返回空
        auto self = self_weak.lock();
        if (!self) {
            // 对象已经被销毁，直接返回，不要访问任何成员
            return;
        }
        
        // 这里可以安全访问成员，因为self持有对象的强引用，确保存活
        this->some_member = 42;
    }
};

注意：这种方式要求Foo对象必须由std::shared_ptr管理（不能直接栈上创建或者用裸指针new后不存到shared_ptr里），否则weak_from_this()会失效。

3. 显式标记对象销毁状态 #

如果不想用智能指针，可以给Foo加一个原子布尔标记，在析构时标记对象已销毁，调用func2后检查这个标记：

#include <atomic>

class Foo {
private:
    std::atomic<bool> is_destroyed_{false};
public:
    ~Foo() {
        // 析构时标记对象已销毁
        is_destroyed_.store(true, std::memory_order_relaxed);
    }
    
    void func() {
        Bar b;
        b.func2();
        
        // 检查对象是否还存活
        if (is_destroyed_.load(std::memory_order_relaxed)) {
            return;
        }
        
        // 安全访问成员
        this->some_member = 42;
    }
};

这个方法的优点是不需要依赖智能指针，缺点是如果func2在其他线程销毁Foo，需要注意内存序的选择（比如用std::memory_order_acquire/release确保同步）。

4. 编译期强制禁止调用后的成员访问 #

如果想从编译层面杜绝错误访问，可以用一个小技巧：让Foo::func()返回一个禁止成员访问的守卫对象，这样调用func()后如果直接访问成员，编译器会报错：

class PostCallGuard {
public:
    // 重载->运算符并delete，禁止通过守卫访问成员
    template<typename T>
    T* operator->() const = delete;
};

class Foo {
public:
    [[nodiscard]] PostCallGuard func() {
        Bar b;
        b.func2();
        
        return {};
    }
};

// 错误示例：编译会报错，因为PostCallGuard的->被delete了
// Foo foo;
// foo.func()->some_member = 42;

这个方法比较hack，但能强制开发者在调用func()后必须显式处理对象生命周期，适合对安全性要求极高的场景。

总的来说，优先选择重构代码让销毁逻辑显式化，这是最可靠也最易维护的方案；如果无法重构，再考虑智能指针或标记法；编译期技巧作为最后的补充手段。

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