shared_ptr 循环引用问题 ​

面试考点 ​

循环引用是 shared_ptr 使用中最经典的陷阱。面试官通过这道题考察你是否理解引用计数的局限性、循环引用为什么导致内存泄漏、以及如何用 weak_ptr 打破循环。

核心概念 ​

当两个或多个对象通过 shared_ptr 相互引用时,形成循环引用。每个对象的引用计数都不会降到 0,即使外部没有任何指针指向它们,它们也不会被销毁,造成内存泄漏。解决方案是将其中一方改为 weak_ptr。

基本示例 ​

cpp
#include <iostream>
#include <memory>
#include <string>

// ============================
// 示例1:循环引用导致内存泄漏
// ============================

class B;  // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr;  // A 持有 B 的 shared_ptr

    A()  { std::cout << "A 构造" << std::endl; }
    ~A() { std::cout << "A 析构" << std::endl; }
};

class B {
public:
    std::shared_ptr<A> a_ptr;  // B 持有 A 的 shared_ptr

    B()  { std::cout << "B 构造" << std::endl; }
    ~B() { std::cout << "B 析构" << std::endl; }
};

void circular_reference_leak() {
    {
        auto a = std::make_shared<A>();  // A 引用计数 = 1
        auto b = std::make_shared<B>();  // B 引用计数 = 1

        a->b_ptr = b;  // B 引用计数 = 2
        b->a_ptr = a;  // A 引用计数 = 2

        // 离开作用域:
        // a 销毁 -> A 引用计数 = 1(还有 b->a_ptr 指着)
        // b 销毁 -> B 引用计数 = 1(还有 a->b_ptr 指着)
        // A 和 B 的引用计数都不为 0,永远不会析构
    }

    std::cout << "离开作用域后:A 和 B 都没有被析构(内存泄漏)" << std::endl;
}

// ============================
// 示例2:用 weak_ptr 打破循环
// ============================

class D;  // 前向声明

class C {
public:
    std::shared_ptr<D> d_ptr;  // 拥有关系:用 shared_ptr

    C()  { std::cout << "C 构造" << std::endl; }
    ~C() { std::cout << "C 析构" << std::endl; }
};

class D {
public:
    std::weak_ptr<C> c_ptr;  // 观察关系:用 weak_ptr(打破循环)

    D()  { std::cout << "D 构造" << std::endl; }
    ~D() { std::cout << "D 析构" << std::endl; }

    void use_c() {
        // weak_ptr 不能直接使用,需要 lock() 转为 shared_ptr
        if (auto sp = c_ptr.lock()) {
            std::cout << "C 对象仍然存活" << std::endl;
        } else {
            std::cout << "C 对象已销毁" << std::endl;
        }
    }
};

void weak_ptr_solution() {
    {
        auto c = std::make_shared<C>();  // C 引用计数 = 1
        auto d = std::make_shared<D>();  // D 引用计数 = 1

        c->d_ptr = d;    // D 引用计数 = 2
        d->c_ptr = c;    // weak_ptr 不增加引用计数,C 引用计数仍为 1

        d->use_c();      // C 仍然存活

        // 离开作用域:
        // c 销毁 -> C 引用计数 = 0 -> C 析构 -> C 中的 d_ptr 销毁 -> D 引用计数 = 1
        // d 销毁 -> D 引用计数 = 0 -> D 析构
    }

    std::cout << "离开作用域后:C 和 D 都正确析构了" << std::endl;
}

// ============================
// 示例3:实际场景——父子关系
// ============================

class Child;

class Parent {
public:
    std::string name;
    std::vector<std::shared_ptr<Child>> children;  // 父拥有子

    Parent(const std::string& n) : name(n) {
        std::cout << "Parent(" << name << ") 构造" << std::endl;
    }
    ~Parent() {
        std::cout << "Parent(" << name << ") 析构" << std::endl;
    }

    void add_child(std::shared_ptr<Child> child);
};

class Child {
public:
    std::string name;
    std::weak_ptr<Parent> parent;  // 子观察父(weak_ptr 避免循环)

    Child(const std::string& n) : name(n) {
        std::cout << "Child(" << name << ") 构造" << std::endl;
    }
    ~Child() {
        std::cout << "Child(" << name << ") 析构" << std::endl;
    }

    void show_parent() {
        if (auto p = parent.lock()) {
            std::cout << name << " 的父节点是 " << p->name << std::endl;
        } else {
            std::cout << name << " 的父节点已不存在" << std::endl;
        }
    }
};

void Parent::add_child(std::shared_ptr<Child> child) {
    children.push_back(child);
}

void parent_child_demo() {
    {
        auto parent = std::make_shared<Parent>("家长");
        auto child1 = std::make_shared<Child>("小明");
        auto child2 = std::make_shared<Child>("小红");

        parent->add_child(child1);
        parent->add_child(child2);

        // 设置反向引用(用 weak_ptr)
        child1->parent = parent;
        child2->parent = parent;

        child1->show_parent();
        child2->show_parent();
    }
    // 所有对象正确析构
}

// ============================
// 示例4:自引用也是循环引用
// ============================

class SelfRef {
public:
    std::shared_ptr<SelfRef> self;  // 自己指向自己

    SelfRef()  { std::cout << "SelfRef 构造" << std::endl; }
    ~SelfRef() { std::cout << "SelfRef 析构" << std::endl; }
};

void self_reference_demo() {
    {
        auto s = std::make_shared<SelfRef>();
        s->self = s;  // 自引用:引用计数 = 2

        // 离开作用域:引用计数降到 1,不会析构
    }
    std::cout << "自引用导致内存泄漏" << std::endl;
}

// ============================
// 示例5:weak_ptr 的使用方法
// ============================

void weak_ptr_usage_demo() {
    std::weak_ptr<int> wp;

    {
        auto sp = std::make_shared<int>(42);
        wp = sp;  // weak_ptr 观察 shared_ptr

        // expired() 检查对象是否存活
        std::cout << "expired: " << wp.expired() << std::endl;  // 0(未过期)

        // lock() 获取 shared_ptr(原子操作,线程安全)
        if (auto locked = wp.lock()) {
            std::cout << "值: " << *locked << std::endl;
        }

        // use_count() 查看引用计数
        std::cout << "use_count: " << wp.use_count() << std::endl;
    }

    // sp 销毁后,对象已释放
    std::cout << "expired: " << wp.expired() << std::endl;  // 1(已过期)

    if (auto locked = wp.lock()) {
        std::cout << "不会执行到这里" << std::endl;
    } else {
        std::cout << "对象已销毁,lock() 返回空" << std::endl;
    }
}

int main() {
    std::cout << "=== 循环引用泄漏 ===" << std::endl;
    circular_reference_leak();

    std::cout << "\n=== weak_ptr 解决方案 ===" << std::endl;
    weak_ptr_solution();

    std::cout << "\n=== 父子关系 ===" << std::endl;
    parent_child_demo();

    std::cout << "\n=== 自引用 ===" << std::endl;
    self_reference_demo();

    std::cout << "\n=== weak_ptr 用法 ===" << std::endl;
    weak_ptr_usage_demo();

    return 0;
}

shared_ptr vs weak_ptr ​

特性shared_ptrweak_ptr
是否拥有对象是(参与引用计数)否(不参与引用计数)
能否直接访问对象可以不可以(需 lock())
是否延长对象生命周期是否
语义所有权观察/弱引用
用途共享所有权打破循环、缓存、观察

常见问题 ​

如何判断应该用 shared_ptr 还是 weak_ptr?

看所有权关系。如果 A "拥有" B(A 存在时 B 应该存在),用 shared_ptr。如果 A 只是"观察"或"引用" B(A 不负责 B 的生命周期),用 weak_ptr。典型例子:父节点用 shared_ptr 持有子节点,子节点用 weak_ptr 引用父节点。

weak_ptr 的 lock() 返回空说明什么?

说明 weak_ptr 观察的对象已经被销毁了。所有拥有它的 shared_ptr 都已经释放,对象内存已回收。

除了循环引用,weak_ptr 还有什么用途?

缓存(cache)场景:用 weak_ptr 持有缓存对象,当对象不再被使用时自动释放。观察者模式:观察者用 weak_ptr 订阅,发布者通知时通过 lock() 检查观察者是否存活。

适用场景 ​

  • 双向关联的对象(父子、夫妻等)
  • 观察者模式中的观察者列表
  • 缓存系统
  • 避免通过回调持有对象导致内存泄漏

注意事项 ​

  • 确定所有权关系后再选择 shared_ptr 还是 weak_ptr
  • weak_ptr 不能直接解引用,必须先 lock()
  • lock() 是线程安全的原子操作
  • 自引用也是循环引用的一种形式
  • 多对象循环引用(A->B->C->A)同样需要打破

总结 ​

循环引用是 shared_ptr 使用中最常见的陷阱。当两个或多个对象通过 shared_ptr 互相引用时,引用计数永远不会降到 0,导致内存泄漏。解决方案是将"非所有权"方向的引用改为 weak_ptr。weak_ptr 不参与引用计数,不影响对象生命周期,使用时需要通过 lock() 转换为 shared_ptr。面试中要能画出循环引用的引用计数变化过程,说明为什么泄漏,以及 weak_ptr 如何打破循环。