C++ Boost智能指针：用weak_ptr解决循环引用内存泄漏

循环引用的内存泄漏风险

shared_ptr 的核心优势在于其引用计数机制：当最后一级强引用断开时，对象会自动销毁。但当存在循环引用时，引用计数无法正确反映对象的实际使用情况。

以下是一个典型的父子循环引用场景：父对象持有子对象，子对象也持有父对象。双方均使用 shared_ptr。

#include <string>
#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>

class parent;
class children;

// 定义类型别名方便阅读
typedef boost::shared_ptr<parent> parent_ptr;
typedef boost::shared_ptr<children> children_ptr;

// 父类定义
class parent
{
public:
    ~parent() { std::cout <<"destroying parent\n"; }
    public:
    // 强引用指向子对象
    children_ptr children;
};

// 子类定义
class children
{
public:
    ~children() { std::cout <<"destroying children\n"; }
    public:
    // 强引用指回父对象，形成闭环
    parent_ptr parent;
};

void test()
{
    // 创建父对象，引用计数变为1
    parent_ptr father(new parent());
    // 创建子对象，引用计数变为1
    children_ptr son(new children);

    // 关联关系
    father->children = son; // son 引用计数变为2（father内部持有一个）
    son->parent = father;   // father 引用计数变为2（son内部持有一个）
}

void main()
{
    std::cout<<"begin test...\n";
    test();
    // 离开test作用域，局部变量father和son析构。
    // 但由于内部互相持有对方，各自的引用计数仅为1而非0。
    // 析构函数不会被调用，导致内存泄漏。
    std::cout<<"end test.\n";
}

运行上述程序会发现，test 函数执行完毕后控制台没有任何析构输出。这是因为退出作用域时，虽然局部的 father 和 son 被销毁，但它们内部的成员变量仍保持着对方的强引用，使得计数永远停在 1，对象无法被释放。

针对此问题，通常有三种解法：

• 手动干预： 在不需要引用时，手动将其中一个指针置为空。这增加了人为错误的风险。
• 普通指针： 在一方（通常是生命周期较短的一方，如子对象）使用裸指针（Raw Pointer）。但这牺牲了安全性，需确保裸指针不访问已释放内存。
• 弱引用智能指针： 引入 boost::weak_ptr。这是最推荐的方式，它不改变引用计数，却能安全地检测对象状态。

强引用与弱引用的区别

理解 weak_ptr 的关键在于区分它与 shared_ptr 对资源的控制权：

1. 强引用 (shared_ptr)
只要存在一个强引用指向对象，对象就必须在内存中存在。强引用负责管理对象的生存周期和内存分配/释放。

2. 弱引用 (weak_ptr)
弱引用不拥有对象的所有权。它不增加对象的引用计数，也不负责对象的生命周期。其本质类似于一个“观察者”或“外部视图”。弱引用主要具备两个特性：

• 安全性： 它可以检测到所管理的对象是否已经被释放。
• 非独占性： 即使对象被释放，弱引用也不会造成悬空指针（Dangling Pointer）导致的立即崩溃，而是可以通过特定接口判断对象状态。

boost::weak_ptr 核心机制

boost::weak_ptr<T> 必须从 boost::shared_ptr<T> 或其他 weak_ptr 转换而来。这意味着它不能独立管理对象，必须依附于某处存在的强引用。

其核心 API 包括：

• T* get(): 获取原始指针。如果对象已销毁，返回 NULL。可直接用于临时访问，但需注意线程安全。
• bool expired(): 检查资源是否已被释放。如果返回 true，表示强引用已不存在，对象可能已死亡。
• shared_ptr<T> lock(): 尝试升级为强引用。如果对象仍存在，返回一个新的 shared_ptr（此时引用计数+1）；如果对象已销毁，返回空的 shared_ptr。

namespace boost {
    template<typename T> class weak_ptr {
    public:
        // 只能由 shared_ptr 或另一个 weak_ptr 构造
        template <typename Y>
        weak_ptr(const shared_ptr<Y>& r);
        weak_ptr(const weak_ptr& r);
        ~weak_ptr();

        // 获取底层裸指针
        T* get() const;
        // 判断是否过期（资源已释放）
        bool expired() const;
        // 锁操作：升级为 shared_ptr
        shared_ptr<T> lock() const;
    };
}

利用 weak_ptr 打破循环引用

要解决前文的内存泄漏问题，只需打破循环中的一环。由于“子对象”的生命周期通常依赖于“父对象”，且子对象对父对象的引用通常是只读的或不包含所有权逻辑，因此将子对象中的 parent 指针从 shared_ptr 改为 weak_ptr。

修改后的 children 类定义如下：

class children
{
public:
    ~children() { std::cout <<"destroying children\n"; }

public:
    // 关键修改：使用 weak_ptr
    boost::weak_ptr<parent> parent;
};

效果分析：
当 father->children = son 和 son->parent = father 执行后：
- father 的引用计数：1 (来自局部变量 father)。
- son 的引用计数：2 (来自局部变量 son + 来自 father->children)。
注意：son->parent 是弱引用，不参与计数计算。

当 test 函数结束：

1. 局部变量 son 析构，son 对象引用计数减 1 变为 1。
2. 局部变量 father 析构，由于 father->children 还持有 son，这里需要仔细追踪，实际上 father 和 son 都是栈上的局部变量，它们同时析构或按顺序析构。

更准确地说：
当 father 析构时，它持有的 children 引用消失，若没有其他外部引用指向 son，则 son 的计数归零，~children 被调用，打印 destroying children。
随后 son 析构。接着处理 father，由于 son 已不存在，且无其他循环，father 引用计数归零，~parent 被调用，打印 destroying parent。

注意事项：
使用 weak_ptr 是一种编译期的设计策略，要求开发者在编码时就预见循环结构。如果在运行时动态形成了意外循环（例如第三方回调未正确处理），依然可能导致泄漏。此外，在使用弱引用的地方，每次访问前都必须通过 lock() 或 expired() 进行检查，以防止对象在等待期间被其他线程销毁。

以上就是 C++ 中使用 Boost 库的 weak_ptr 解决 shared_ptr 循环引用内存泄漏的详细内容，更多关于 C++ 智能指针与内存管理的资料请关注本站其它相关文章！