C++如何实现无需堆分配的std::weak_ptr语义监测对象生命周期

结论 #

完全可行。std::weak_ptr的核心是绑定到std::shared_ptr的控制块监测引用计数，而非强制要求托管对象分配在堆上，只要给栈/全局/静态存储的对象关联对应控制块，就能实现不需要堆分配对象的生命周期监测能力，且不会延长对象的存活时间。

推荐实现方案 #

方案1：使用std::shared_ptr别名构造（标准库原生实现，无自定义代码） #

利用std::shared_ptr的别名构造函数，让shared_ptr的控制块托管一个无操作的dummy对象，同时指向栈上的目标对象，即可直接生成标准std::weak_ptr用于生命周期监测。
示例代码如下：

#include <memory>
#include <iostream>

struct TestObj {
    int value = 100;
};

int main() {
    // 栈上分配目标对象，业务对象无堆分配
    TestObj stack_obj;
    // 别名构造shared_ptr：第一个参数是托管的dummy空指针，第二个是实际指向的栈对象地址
    std::shared_ptr<TestObj> life_guard{std::shared_ptr<void>(), &stack_obj};
    // 生成对应weak_ptr用于监测
    std::weak_ptr<TestObj> observer = life_guard;

    // 对象存活时lock成功
    if (auto locked = observer.lock()) {
        std::cout << "对象存活，值为：" << locked->value << std::endl;
    }

    // 当栈对象要销毁前重置life_guard，也可直接让life_guard和stack_obj在同一个作用域自动销毁
    life_guard.reset();
    // 对象销毁后lock失败
    if (!observer.lock()) {
        std::cout << "对象已销毁" << std::endl;
    }

    return 0;
}

注意事项：你需要自行保证life_guard的生命周期和目标栈对象完全一致，否则weak_ptr::lock()可能返回指向已销毁栈内存的野指针。

方案2：自定义轻量生命周期监测器（更低开销） #

如果不需要兼容标准std::weak_ptr接口，可以自己实现更轻量化的方案，仅用一个原子标记记录对象存活状态：

#include <memory>
#include <atomic>
#include <iostream>

struct LifeControl {
    std::atomic<bool> is_alive = true;
};

// 监测器，等价于自定义weak_ptr
class ObjObserver {
public:
    explicit ObjObserver(std::shared_ptr<LifeControl> ctrl) : m_ctrl(std::move(ctrl)) {}
    bool is_alive() const {
        auto locked = m_ctrl.lock();
        return locked && locked->is_alive;
    }
private:
    std::weak_ptr<LifeControl> m_ctrl;
};

// 被监测对象的基类/成员，自动管理生命周期标记
class LifeTracked {
public:
    LifeTracked() : m_ctrl(std::make_shared<LifeControl>()) {}
    ~LifeTracked() {
        m_ctrl->is_alive = false;
    }
    ObjObserver get_observer() const {
        return ObjObserver(m_ctrl);
    }
private:
    std::shared_ptr<LifeControl> m_ctrl;
};

// 你的业务类型，继承LifeTracked即可支持生命周期监测
struct TestObj : LifeTracked {
    int value = 100;
};

int main() {
    // 栈上分配对象，仅控制块有极小的堆开销，业务对象本身无堆分配
    TestObj stack_obj;
    auto observer = stack_obj.get_observer();

    std::cout << std::boolalpha << "对象是否存活：" << observer.is_alive() << std::endl; // 输出true

    {
        TestObj inner_stack_obj;
        auto inner_observer = inner_stack_obj.get_observer();
        std::cout << "内层对象是否存活：" << inner_observer.is_alive() << std::endl; // 输出true
    }

    std::cout << "内层对象是否存活：" << observer.is_alive() << std::endl; // 输出false
    return 0;
}

方案优势：仅控制块有极小的堆开销（单个原子变量+两个引用计数），业务对象完全可以分配在栈上，逻辑更透明，不存在野指针风险。

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