C++ 智能指针 weak ptr 

std::weak_ptr 是 C++ 标准库中的一个智能指针类，用于解决 std::shared_ptr 可能引发的循环引用问题。循环引用可能导致内存泄漏，因为引用计数无法降为零，从而无法释放对象。

std::weak_ptr是一种弱引用，它允许你观测由 std::shared_ptr 管理的对象，但不会增加对象的引用计数。换句话说，std::weak_ptr 不拥有所指向对象的所有权，因此不会影响对象的生命周期。当 std::shared_ptr 管理的对象被销毁后，对应的 std::weak_ptr 会自动失效，指向空值。

本篇文章从以下两个方面来讲解 weak_ptr 的使用：

1. weak_ptr 创建和使用
2. shared_ptr 引用计数的缺陷
3. weak_ptr 使用示例

1. weak_ptr 创建和使用

weak_ptr 是作为 shared_ptr 辅助角色存在，不会被直接用来管理动态对象。所以：

1. 我们不会直接创建 weak_ptr 去管理动态对象
2. weak_ptr 只能通过 shared_ptr 对象创建
3. weak_ptr 引用 shared_ptr 对象时，并不会增加引用计数
4. 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
析构函数

2. shared_ptr 循环引用

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 这种现象，叫做循环引用。

1. 由于循环引用，导致两个 LinkNode 关联的引用计数为 2
2. 当 test 函数生命周期结束，node1 和 node2 的析构函数调用，两个 LinkNode 对象引用计数 -1，引用计数为 1
3. 只有当 LinkNode 实际被销毁时，才会调用 prev 和 next 的析构函数。

第 2、3 点是一对矛盾的存在：

1. 只有 prev 和 next 被销毁，LinkNode 才会被真正释放
2. 只有两个 LinkNode 被释放，prev 和 next 才会被销毁

3. weak_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;
	// 使用 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 的讲解完毕了，希望对你有帮助！