51工具盒子std::weak_ptr 是 C++ 标准库中的一个智能指针类，用于解决 std::shared_ptr 可能引发的循环引用问题。循环引用可能导致内存泄漏，因为引用计数无法降为零，从而无法释放对象。
std::weak_ptr是一种弱引用，它允许你观测由 std::shared_ptr 管理的对象，但不会增加对象的引用计数。换句话说，std::weak_ptr 不拥有所指向对象的所有权，因此不会影响对象的生命周期。当 std::shared_ptr 管理的对象被销毁后，对应的 std::weak_ptr 会自动失效，指向空值。
本篇文章从以下两个方面来讲解 weak_ptr 的使用：
-
weak_ptr 创建和使用
-
shared_ptr 引用计数的缺陷
-
weak_ptr 使用示例
-
weak_ptr 创建和使用 {#title-0}
weak_ptr 是作为 shared_ptr 辅助角色存在，不会被直接用来管理动态对象。所以：
- 我们不会直接创建 weak_ptr 去管理动态对象
- weak_ptr 只能通过 shared_ptr 对象创建
- weak_ptr 引用 shared_ptr 对象时，并不会增加引用计数
- weak_ptr 不直接操作 shared_ptr 管理的对象，但允许间接操作 shared_ptr 管理的对象
#if 1
#include <iostream>
using namespace std;
class Person
{
public:
Person(int, int)
{
cout << "构造函数" << endl;
}
void show()
{
cout << "Person::show 函数" << endl;
}
~Person()
{
cout << "析构函数" << endl;
}
};
void test()
{
// weak_ptr 是对 shared_ptr 的辅助，其自身并不拥有资源所有权
shared_ptr<Person> sp1 = make_shared<Person>(10, 20);
// 通过拷贝 shared_ptr 对象创建 weak_ptr 对象
weak_ptr<Person> wp1(sp1);
// weak_ptr 使用时，不能直接访问对象成员
// 必须使用 lock 方法返回一个 shared_ptr 对象（会增加引用）
if (wp1.expired())
{
return;
}
auto sp2 = wp1.lock();
sp2->show();
// 可以将 shared_ptr 赋值给 weak_ptr 对象
weak_ptr<Person> wp2;
wp2 = sp1;
// weak_ptr 相当于一个不增加引用的 shared_ptr
cout << "sp1:" << sp1.use_count() << endl;
cout << "sp2:" << sp2.use_count() << endl;
cout << "wp1:" << wp1.use_count() << endl;
cout << "wp2:" << wp2.use_count() << endl;
}
int main()
{
test();
return 0;
}
#endif
构造函数
Person::show 函数
sp1:2
sp2:2
wp1:2
wp2:2
析构函数
- shared_ptr 循环引用 {#title-1}
shared_ptr 以引用计数机制实现了对象共享，但是，引用计数机制本身存在一个自身难以解决的问题：循环引用。
#if 1
#include <iostream>
using namespace std;
// 双向链表节点
class LinkNode
{
public:
LinkNode(int value)
{
cout << "LinkNode 构造函数" << endl;
data = value;
}
~LinkNode()
{
cout << "LinkNode 析构函数" << endl;
}
public:
int data;
shared_ptr<LinkNode> prev;
shared_ptr<LinkNode> next;
};
void test()
{
// 创建两个链表节点
shared_ptr<LinkNode> node1(new LinkNode(10));
shared_ptr<LinkNode> node2(new LinkNode(20));
// 建立节点之间的关系
node1->next = node2;
node2->prev = node1;
}
int main()
{
test();
return 0;
}
#endif
程序输出结果：
LinkNode 构造函数
LinkNode 构造函数
我们对链表节点使用 shared_ptr 进行了管理，防止出现忘记释放而导致的内存泄漏。但是，通过程序运行的结果看到，两个 LinkNode 只调用了构造函数，并没有调用析构函数，出现了内存泄漏产生。
这是由于什么原因导致的呢？
上图中， node1 对象内部引用 node2 对象，node2 对象内部引用 node1 这种现象，叫做循环引用。
- 由于循环引用，导致两个 LinkNode 关联的引用计数为 2
- 当 test 函数生命周期结束，node1 和 node2 的析构函数调用，两个 LinkNode 对象引用计数 -1，引用计数为 1
- 只有当 LinkNode 实际被销毁时，才会调用 prev 和 next 的析构函数。
第 2、3 点是一对矛盾的存在：
-
只有 prev 和 next 被销毁，LinkNode 才会被真正释放
-
只有两个 LinkNode 被释放，prev 和 next 才会被销毁
-
weak_ptr 使用示例 {#title-2}
当一个对象持有对另一个对象的引用，而后者又持有对前者的引用时，就会产生循环引用。所以，要打破这种循环的话，可以使用在发生循环引用的地方使用弱引用。
#if 1
#include <iostream>
using namespace std;
// 双向链表节点
class LinkNode
{
public:
LinkNode(int value)
{
cout << "LinkNode 构造函数" << endl;
data = value;
}
~LinkNode()
{
cout << "LinkNode 析构函数" << endl;
}
public:
int data;
// 使用 weak_ptr 代替 shared_ptr
weak_ptr<LinkNode> prev;
weak_ptr<LinkNode> next;
};
void test()
{
// 创建两个链表节点
shared_ptr<LinkNode> node1(new LinkNode(10));
shared_ptr<LinkNode> node2(new LinkNode(20));
// 建立节点之间的关系
node1->next = node2;
node2->prev = node1;
}
int main()
{
test();
return 0;
}
#endif
程序的输出结果：
LinkNode 构造函数
LinkNode 构造函数
LinkNode 析构函数
LinkNode 析构函数
至此，关于 weak_ptr 的讲解完毕了，希望对你有帮助！
