原创实现一个简化版 weak_ptr：循环引用的终结者

 2025-7-16 20:46  4732 6 6 分类: 物联网

在现代 C++ 工程中，shared_ptr 常用于多个模块共享资源，但这也引入一个严重隐患——循环引用（reference cycle），即两个对象相互持有 shared_ptr 指针，导致它们永远不会释放。

解决方案正是：weak_ptr —— 弱引用观察者，它不拥有资源，只用于访问和判断对象是否还存在。

回顾循环引用问题本质
手写 WeakPtr<T> 与 SharedPtr<T> 配合使用
实现引用计数分离（强计数与弱计数）
构建对象生命周期判断机制

一、循环引用问题复现

cpp
复制编辑
structNode {
    std::shared_ptr<Node> next;
};

intmain() {
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();
    a->next = b;
    b->next = a;  // ❌ a 和 b 永远不会释放
}

因为它们互相持有对方的 shared_ptr，导致引用计数永远为 1。

二、解决方案：引入弱引用 `weak_ptr`

cpp
复制编辑
structNode {
    std::weak_ptr<Node> next;  // ✅ 使用 weak_ptr 不增加引用计数
};

cpp
复制编辑
if (auto np = node->next.lock()) {
    // 使用 np，它是 shared_ptr
}

weak_ptr 并不拥有资源，而是观测 shared_ptr 是否还活着。

三、我们的手写框架目标

要支持 weak_ptr，我们需对控制块进行重构：

字段	作用
`strong_count`	`SharedPtr` 引用数
`weak_count`	`WeakPtr` 引用数
`ptr`	被管理对象
`destroyed` 标志	用于判断资源是否已释放

SharedPtr<T> 正常管理强引用
WeakPtr<T> 共享控制块，但不增加 strong_count
WeakPtr::lock() 可转换为 SharedPtr<T>（若资源未释放）

四、重构控制块结构

cpp
复制编辑
template<typename T>
classControlBlock {
public:
    T* ptr;
    size_t strong_count = 1;
    size_t weak_count = 0;

    ControlBlock(T* p) : ptr(p) {}

    ~ControlBlock() = default;

    voidreleaseStrong() {
        if (--strong_count == 0) {
            delete ptr;
            ptr = nullptr;
            if (weak_count == 0) deletethis;
        }
    }

    voidreleaseWeak() {
        if (--weak_count == 0 && strong_count == 0) {
            deletethis;
        }
    }
};

五、SharedPtr 修改

cpp
复制编辑
template<typename T>
classSharedPtr {
    ControlBlock<T>* ctrl = nullptr;

public:
    SharedPtr() = default;

    explicitSharedPtr(T* p) {
        ctrl = newControlBlock<T>(p);
    }

    SharedPtr(const SharedPtr& other) {
        ctrl = other.ctrl;
        if (ctrl) ctrl->strong_count++;
    }

    ~SharedPtr() {
        if (ctrl) ctrl->releaseStrong();
    }

    SharedPtr& operator=(const SharedPtr& other) {
        if (this != &other) {
            if (ctrl) ctrl->releaseStrong();
            ctrl = other.ctrl;
            if (ctrl) ctrl->strong_count++;
        }
        return *this;
    }

    T* get()const { return ctrl ? ctrl->ptr : nullptr; }

    size_tuse_count()const { return ctrl ? ctrl->strong_count : 0; }

    friendclassWeakPtr<T>;
};

六、实现 WeakPtr<T>

cpp
复制编辑
template<typename T>
classWeakPtr {
    ControlBlock<T>* ctrl = nullptr;

public:
    WeakPtr() = default;

    WeakPtr(const SharedPtr<T>& sp) {
        ctrl = sp.ctrl;
        if (ctrl) ctrl->weak_count++;
    }

    WeakPtr(const WeakPtr& other) {
        ctrl = other.ctrl;
        if (ctrl) ctrl->weak_count++;
    }

    ~WeakPtr() {
        if (ctrl) ctrl->releaseWeak();
    }

    SharedPtr<T> lock()const {
        if (ctrl && ctrl->strong_count > 0) {
            returnSharedPtr<T>(*this);
        }
        returnSharedPtr<T>();
    }

private:
    friendclassSharedPtr<T>;
    WeakPtr(ControlBlock<T>* c) : ctrl(c) {
        if (ctrl) ctrl->weak_count++;
    }
};

七、支持 SharedPtr(WeakPtr) 构造

cpp
复制编辑
SharedPtr(const WeakPtr<T>& wp) {
    ctrl = wp.ctrl;
    if (ctrl && ctrl->strong_count > 0) {
        ctrl->strong_count++;
    } else {
        ctrl = nullptr;
    }
}

八、使用示例

cpp
复制编辑
SharedPtr<int> sp1(newint(123));
WeakPtr<int> wp1 = sp1;

{
    SharedPtr<int> sp2 = wp1.lock();
    if (sp2.get()) std::cout << *sp2 << std::endl;  // 输出 123
}

sp1 = SharedPtr<int>();  // 引用计数为 0，资源释放

SharedPtr<int> sp3 = wp1.lock();
if (!sp3.get()) std::cout << "对象已被释放" << std::endl;

复制编辑
123
对象已被释放

九、边界处理建议

若构造 WeakPtr 时控制块已空，则 lock() 返回空指针
若从 WeakPtr 构造 SharedPtr，需要检查 strong_count > 0
控制块在 strong 和 weak 都归零时才销毁

十、小结

本篇我们实现了一个完整的弱引用智能指针 WeakPtr<T>，它具有：

与 SharedPtr<T> 协同共享控制块
不增加资源引用计数
可通过 lock() 安全获取临时所有权
解决 shared_ptr 循环引用问题

通过 SharedPtr + WeakPtr 的配合，我们构建了一个完整的资源管理框架，这也是现代 C++ 智能指针设计的核心理念。

上一篇： Python 实战构建图片整理助手
返回列表

PARTNER CONTENT

黄烨锋 2025-12-31

文章评论（0条评论）

原创 实现一个简化版 weak_ptr：循环引用的终结者