非全局资源管理器场景下RAII封装的生命周期问题

当前实现中，MyObject通过引用持有Manager，要求用户必须保证Manager的生命周期严格长于MyObject，否则析构时调用deallocate会触发未定义行为。要解决这个问题，同时保留RAII自动释放资源的特性，且不在库级接口中暴露智能指针、弱指针或原始指针，可以采用以下两种实用方案：

方案一：将Manager封装为安全值类型，让MyObject持有Manager拷贝 #

核心思路是把Manager设计为带内部引用计数的值类型，对外暴露值语义，隐藏内部的共享状态实现。MyObject不再持有Manager的引用，而是直接持有Manager的拷贝，彻底切断生命周期依赖。

代码实现： #

// 资源表示类型，具体形式可根据需求定义
struct obj_rep {};

struct Manager {
    Manager() : impl_(new Impl{}) {}
    
    // 拷贝构造：共享内部实现，递增引用计数
    Manager(const Manager& other) : impl_(other.impl_) {
        ++impl_->ref_count;
    }
    
    // 拷贝赋值：先清理原实现，再共享新实现
    Manager& operator=(const Manager& other) {
        if (this != &other) {
            if (--impl_->ref_count == 0) {
                delete impl_;
            }
            impl_ = other.impl_;
            ++impl_->ref_count;
        }
        return *this;
    }
    
    // 移动构造/赋值：直接转移内部实现所有权，避免引用计数操作
    Manager(Manager&& other) noexcept : impl_(other.impl_) {
        other.impl_ = nullptr;
    }
    
    Manager& operator=(Manager&& other) noexcept {
        if (this != &other) {
            if (impl_ && --impl_->ref_count == 0) {
                delete impl_;
            }
            impl_ = other.impl_;
            other.impl_ = nullptr;
        }
        return *this;
    }
    
    ~Manager() {
        if (impl_ && --impl_->ref_count == 0) {
            delete impl_;
        }
    }
    
    // 对外暴露的资源分配/释放接口
    obj_rep allocate() {
        return impl_->allocate();
    }
    
    void deallocate(obj_rep rep) {
        impl_->deallocate(rep);
    }

private:
    // 内部实现类：封装实际资源管理逻辑和引用计数
    struct Impl {
        int ref_count = 1;
        
        obj_rep allocate() {
            // 实际资源分配逻辑（例如从资源池取出、创建新资源）
            return obj_rep{};
        }
        
        void deallocate(obj_rep rep) {
            // 实际资源释放逻辑（例如归还到资源池、销毁资源）
        }
    };
    
    Impl* impl_; // 内部使用原始指针，但对外完全隐藏
};

struct MyObject {
    // 接收Manager的值（或右值），直接持有拷贝
    explicit MyObject(Manager mng) : mng_(std::move(mng)) {
        rep_ = mng_.allocate();
    }
    
    ~MyObject() {
        // 使用自身持有的Manager拷贝释放资源，无生命周期风险
        mng_.deallocate(rep_);
    }
    
    // 遵循Rule of 5：禁用拷贝（避免资源重复释放），允许移动
    MyObject(const MyObject&) = delete;
    MyObject& operator=(const MyObject&) = delete;
    
    MyObject(MyObject&&) = default;
    MyObject& operator=(MyObject&&) = default;

private:
    obj_rep rep_;
    Manager mng_; // 持有Manager的拷贝，而非引用
};

方案优势： #

• 彻底消除生命周期依赖：MyObject持有独立的Manager拷贝，即使原Manager被销毁，内部共享的Impl仍会因为引用计数未归零而保持有效，析构时能安全释放资源。
• 严格保留RAII特性：MyObject析构时自动触发资源释放，无需用户手动干预。
• 接口简洁安全：对外仅暴露值类型，用户无需处理任何指针类型，完全符合C++库级接口的设计规范。

方案二：Manager作为工厂，返回绑定销毁逻辑的封装句柄 #

如果不想让MyObject持有Manager拷贝，可以让Manager作为工厂，返回一个封装好的RAII句柄，句柄内部绑定Manager的生命周期，但对外隐藏指针实现。不过这种方式需要额外保证Manager的生命周期，适合Manager生命周期明确且稳定的场景。

代码实现： #

struct obj_rep {};

struct Manager {
    // 对外暴露的RAII句柄，隐藏内部指针
    class ObjectHandle {
        friend struct Manager;
        // 仅允许Manager创建句柄
        ObjectHandle(obj_rep rep, Manager* mng) : rep_(rep), mng_(mng) {}
        
    public:
        ~ObjectHandle() {
            if (mng_) {
                mng_->deallocate(rep_);
            }
        }
        
        // Rule of 5：禁用拷贝，允许移动
        ObjectHandle(const ObjectHandle&) = delete;
        ObjectHandle& operator=(const ObjectHandle&) = delete;
        
        ObjectHandle(ObjectHandle&& other) noexcept : rep_(other.rep_), mng_(other.mng_) {
            other.mng_ = nullptr;
        }
        
        ObjectHandle& operator=(ObjectHandle&& other) noexcept {
            if (this != &other) {
                if (mng_) {
                    mng_->deallocate(rep_);
                }
                rep_ = other.rep_;
                mng_ = other.mng_;
                other.mng_ = nullptr;
            }
            return *this;
        }
        
        // 提供资源访问接口
        obj_rep get() const { return rep_; }

    private:
        obj_rep rep_;
        Manager* mng_; // 内部使用原始指针，但对外完全隐藏
    };
    
    // 工厂方法：创建并返回RAII句柄
    ObjectHandle create_object() {
        auto rep = allocate();
        return ObjectHandle(rep, this);
    }
    
private:
    obj_rep allocate() { return obj_rep{}; }
    void deallocate(obj_rep rep) {}
};

注意事项： #

这种方案下，用户仍需保证Manager的生命周期长于ObjectHandle，如果要彻底消除依赖，可以结合方案一的引用计数思路，让ObjectHandle持有Manager的拷贝而非指针。

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