weak_ptr的用处_weak_ptr的作用_kyowill的博客-CSDN博客
循环引用问题
#include <memory>
class B; // 前向声明
class A {
public:
std::shared_ptr<B> b_ptr;
};
class B {
public:
std::shared_ptr<A> a_ptr;
};
int main() {
std::shared_ptr<A> a = std::make_shared<A>();
std::shared_ptr<B> b = std::make_shared<B>();
a->b_ptr = b;
b->a_ptr = a;
return 0;
}
见上图，当 main 函数结束时，a 和 b 这两个共享指针会被销毁，但是因为 a->b_ptr 和 b->a_ptr 的共享指针引用仍然存在，所以 A 和 B 对象共享指针引用计数都从2变为1，于是这两个对象都没有正常销毁
为了解决循环引用的问题，可以使用 std::weak_ptr，它可以避免形成循环引用，因为** std::weak_ptr 不会增加引用计数**。只有当需要使用对象时，可以将 std::weak_ptr 转换成 std::shared_ptr，如果对象已经被销毁，则转换会失败。
以下是使用 std::weak_ptr 改进上述代码的示例：
#include <memory>
class B; // Forward declaration
class A {
public:
std::shared_ptr<B> b_ptr;
};
class B {
public:
std::weak_ptr<A> a_ptr; // Using weak_ptr here
};
int main() {
std::shared_ptr<A> a = std::make_shared<A>();
std::shared_ptr<B> b = std::make_shared<B>();
a->b_ptr = b;
b->a_ptr = a;
return 0;
}
这样，A 和 B 之间的循环引用就不会造成内存泄漏。
具体说明 std::weak_ptr 转换成 std::shared_ptr然后使用？
当你需要使用 std::weak_ptr 指向的对象时，你可以通过调用 std::weak_ptr 的 lock() 成员函数来尝试将它转换为一个有效的 std::shared_ptr。这个操作会检查所指向的对象是否还存在，如果存在，就会返回一个指向该对象的有效 std::shared_ptr，否则返回一个空的 std::shared_ptr。
在你的代码中，如果你需要使用 B 对象所指向的 A 对象，你可以这样做：
#include <memory>
class B; // Forward declaration
class A {
public:
std::shared_ptr<B> b_ptr;
};
class B {
public:
std::weak_ptr<A> a_ptr; // Using weak_ptr here
};
int main() {
std::shared_ptr<A> a = std::make_shared<A>();
std::shared_ptr<B> b = std::make_shared<B>();
a->b_ptr = b;
b->a_ptr = a;
// Using weak_ptr to access the object
std::shared_ptr<A> a_from_b = b->a_ptr.lock();
if (a_from_b) {
// You can safely use a_from_b here
} else {
// The object has been destroyed
}
return 0;
}
在上面的代码中，通过调用 b->a_ptr.lock()，你可以获得一个指向 A 对象的 std::shared_ptr，如果 A 对象仍然存在的话。如果 A 对象已经被销毁，a_from_b 将会是一个空的 std::shared_ptr。这样你就可以在使用对象之前检查它是否还存在，避免悬空指针的问题。
注意
- 虽然通过弱引用指针可以有效的解除循环引用，但这种方式必须在能预见会出现循环引用的情况下才能使用，即这个仅仅是一种编译期的解决方案，如果程序在运行过程中出现了循环引用，还是会造成内存泄漏的。因此，不要认为只要使用了智能指针便能杜绝内存泄漏。
具体说明
weak_ptr是为配合shared_ptr而引入的一种智能指针，它更像是shared_ptr的一个助手，而不是一个智能指针。它的最大作用在于协助shared_ptr工作，像旁观者那样观测资源的使用情况。weak_ptr被设计为与shared_ptr协同工作，可以从一个shared_ptr或者另外一个weak_ptr对象构造，获得资源的观测权限。但weak_ptr没有共享资源，它的构造不会引入指针引用技术的增加，同样，weak_ptr析构时也不会导致引用技术减少，它只是一个静静的观察着。weak_ptr的一个很重要作用是：打破循环引用。
让我们一步步来分析循环引用问题。
- SharedPtrNode
#ifndef SHAREPTRNODE_H_
#define SHAREPTRNODE_H_
#include <iostream>
using namespace std;
#include <boost/smart_ptr.hpp>
using namespace boost;
class SharePtrNode {
public :
int spNodeId;
SharePtrNode();
SharePtrNode( int nId);
virtual ~SharePtrNode();
typedef boost::shared_ptr<SharePtrNode> ptr_type;
ptr_type next;
};
#endif /* SHAREPTRNODE_H_ */
#include "SharePtrNode.h"
#include <iomanip> //for setw and setfill
SharePtrNode::SharePtrNode():SharePtrNode(0) {
// TODO Auto-generated constructor stub
}
SharePtrNode::SharePtrNode( int nId)
{
spNodeId = nId;
cout << "SharePtrNode, [spNodeId:"
<< setw(4) << setfill( '0' ) << spNodeId << "]" << endl;
}
SharePtrNode::~SharePtrNode() {
// TODO Auto-generated destructor stub
cout << "~SharePtrNode, [spNodeId:"
<< setw(4) << setfill( '0' ) << spNodeId << "]" << endl;
}
一个SharePtrNode对象包含一个自身id(spNodeId)和一个指针：ptr_type next。这个指针是一个shared_ptr类型的指针。基于上述SharePtrNode类，我们构建一个简单的使用场景：动态创建两个SharePtrNode对象。
void Case03_ShareAndWeakPtrLoopRef_1()
{
auto sharedPtrNode1 = boost::make_shared<SharePtrNode>(1);
auto sharedPtrNode2 = boost::make_shared<SharePtrNode>(2);
}
由于是通过shared_ptr管理的两个对象，因此，两个对象会在函数退出时自动销毁，且销毁的顺序与创建的顺序相反。
——> Case03_ShareAndWeakPtrLoopRef_1
SharePtrNode, [spNodeId:0001]
SharePtrNode, [spNodeId:0002]
~SharePtrNode, [spNodeId:0002]
~SharePtrNode, [spNodeId:0001]
这种场景下一切似乎都非常合理。
引用示意图如下：
那如果对case场景做进一步补充：将sharedPtrNode1的next指针指向sharedPtrNode2，会产生什么结果呢？
void Case03_ShareAndWeakPtrLoopRef_2()
{
auto sharedPtrNode1 = boost::make_shared<SharePtrNode>(1);
auto sharedPtrNode2 = boost::make_shared<SharePtrNode>(2);
sharedPtrNode1->next = sharedPtrNode2;
}
这个时候，会有什么输出出现呢？
——> Case03_ShareAndWeakPtrLoopRef_2
SharePtrNode, [spNodeId:0001]
SharePtrNode, [spNodeId:0002]
~SharePtrNode, [spNodeId:0001]
~SharePtrNode, [spNodeId:0002]
顺序变了，为什么会这样？因为在执行sharedPtrNode1->next = sharedPtrNode2;的时候实际上SharedPtrNode2的引用计数已经从1增加到了2，当函数退出时，首先SharedPtrNode2先析构，此时SharedPtrNode2的引用技术从2减回到1，因为不到0，因此实际的SharedPtrNode2此时还不能销毁，析构函数没有被调用。而此后SharedPtrNode1进行析构，此时因为SharedPtrNode1的引用计数原本只有1，此时降低到0，因此SharedPtrNode1的析构函数被调用：“~SharePtrNode, [spNodeId:0001]”，在SharedPtrNode1进行析构的时候，SharedPtrNode1的成员变量sharedPtrNode1->next也会一并析构，此时由于next指向的节点引用计数已经是1了，析构的时候，变成0，因此执行最终指向节点的SharePtrNode2的析构，因此“~SharePtrNode, [spNodeId:0002]”输出。这也就是为什么node2在node1之后析构的原因。
引用示意图如下：
- 共享指针就是用来管理对象的生命周期的，对象的是否析构要看指向该对象的共享指针的引用计数是否降为0，为0则析构，否则不析构。（注意区分共享指针对象的析构≠共享指针指向对象的析构）
- 析构时，指向B的共享指针对象b先析构，此时指向B的共享指针引用计数由2变为1，但不是0，所以B对象的析构函数未被调用
- 而后，指向A的共享指针对象a先析构，此时指向A的共享指针引用计数由1变为0，于是A的析构函数被调用
- 由于对象A的析构，其成员——指向B对象的共享指针对象a被析构，此时B的共享指针引用计数由1变为0，这时B的析构函数被调用
- 这也就解释了上述的析构函数调用顺序问题
在进一步构建一个更为复杂一点的场景：再sharedPtrNode2的next指针指向sharedPtrNode1，会产生什么结果呢？
void Case03_ShareAndWeakPtrLoopRef_3()
{
auto sharedPtrNode1 = boost::make_shared<SharePtrNode>(1);
auto sharedPtrNode2 = boost::make_shared<SharePtrNode>(2);
sharedPtrNode1->next = sharedPtrNode2;
sharedPtrNode2->next = sharedPtrNode1;
}
我们可以看到，此时的输出结果如下：
——> Case03_ShareAndWeakPtrLoopRef_3
SharePtrNode, [spNodeId:0001]
SharePtrNode, [spNodeId:0002]
两个对象都值进行了初始化，而没有进行析构！
这里可参见开头的解释。
