shared_ptr 循环引用问题
面试考点
循环引用是 shared_ptr 使用中最经典的陷阱。面试官通过这道题考察你是否理解引用计数的局限性、循环引用为什么导致内存泄漏、以及如何用 weak_ptr 打破循环。
核心概念
当两个或多个对象通过 shared_ptr 相互引用时,形成循环引用。每个对象的引用计数都不会降到 0,即使外部没有任何指针指向它们,它们也不会被销毁,造成内存泄漏。解决方案是将其中一方改为 weak_ptr。
基本示例
#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_ptr | weak_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 如何打破循环。