weak_ptr的用处

看到一篇关于weak_ptr的好文

weak_ptr是为配合shared_ptr而引入的一种智能指针，它更像是shared_ptr的一个助手，而不是一个智能指针。它的最大作用在于协助shared_ptr工作，像旁观者那样观测资源的使用情况。weak_ptr被设计为与shared_ptr协同工作，可以从一个shared_ptr或者另外一个weak_ptr对象构造，获得资源的观测权限。但weak_ptr没有共享资源，它的构造不会引入指针引用技术的增加，同样，weak_ptr析构时也不会导致引用技术减少，它只是一个静静的观察着。weak_ptr的一个很重要作用是：打破循环引用。

让我们一步步来分析循环引用问题。

1. SharedPtrNode

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#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_ */

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#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对象。

1 2 3 4 5

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，会产生什么结果呢？

1 2 3 4 5 6 7

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之后析构的原因。

在进一步构建一个更为复杂一点的场景：再sharedPtrNode2的next指针指向sharedPtrNode1，会产生什么结果呢？

1 2 3 4 5 6 7 8

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]

两个对象都值进行了初始化，而没有进行析构！原因如下图所示：

在使用shared_ptr时，由于这种“循环引用”的存在，导致被shared_ptr管理的两个对象node(1)和node(2)均没有被释放。

针对上述问题，可将原有定义为shared_ptr的next调整为weak_ptr，因为通过weak_ptr的赋值，实际节点的引用计数将不做累加，因此不存在上述循环引用的问题。

2. WeakPtrNode

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#ifndef WEAKPTRNODE_H_ #define WEAKPTRNODE_H_   #include <iostream> using  namespace  std;   #include <boost/smart_ptr.hpp> using  namespace  boost;   class  WeakPtrNode { public :      int   wpNodeId;      WeakPtrNode();      WeakPtrNode( int  nId);      virtual  ~WeakPtrNode();        typedef  boost::weak_ptr<WeakPtrNode> ptr_type;      ptr_type next; };   #endif /* WEAKPTRNODE_H_ */

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#include "WeakPtrNode.h" #include <iomanip>  //for setw and setfill   WeakPtrNode::WeakPtrNode():WeakPtrNode(0) {      // TODO Auto-generated constructor stub   }   WeakPtrNode::~WeakPtrNode() {      // TODO Auto-generated destructor stub      cout <<  "~WeakPtrNode, [wpNodeId:"                       << setw(4) << setfill( '0' ) << wpNodeId <<  "]"  << endl; }   WeakPtrNode::WeakPtrNode( int  nId) {      wpNodeId = nId;      cout <<  "WeakPtrNode, [wpNodeId:"                       << setw(4) << setfill( '0' ) << wpNodeId <<  "]"  << endl; }

此时，如果执行上面的测试场景，将会出现我们满意的资源自动释放的结果：

1 2 3 4 5 6 7 8

void  Case03_ShareAndWeakPtrLoopRef_4() {      auto  weakPtrNode3 = boost::make_shared<WeakPtrNode>(3);      auto  weakPtrNode4 = boost::make_shared<WeakPtrNode>(4);        weakPtrNode3->next = weakPtrNode4;      weakPtrNode4->next = weakPtrNode3; }

——> Case03_ShareAndWeakPtrLoopRef_4 WeakPtrNode, [wpNodeId:0003] WeakPtrNode, [wpNodeId:0004] ~WeakPtrNode, [wpNodeId:0004] ~WeakPtrNode, [wpNodeId:0003]

之所以都会释放，就在于weak_ptr的使用，weak_ptr作为“观察者”，保留了将观察对象提升为share_ptr，并进一步进行操作的权利，但在不需要操作时，则保持自己普通观察员的身份。

通过上述例子可以看出，weak_ptr可以有效解决shared_ptr循环引用的问题。而实际上，当我们需要使用weak_ptr管理的实际内容时，为确保在使用过程中其他shared_ptr不会将内容释放，weak_ptr需要进行升级。weak_ptr.lock()将提升返回一个对应的shared_ptr.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

void  Case03_ShareAndWeakPtrLoopRef_5() {      auto  weakPtrNode3 = boost::make_shared<WeakPtrNode>(3);      {          auto  weakPtrNode4 = boost::make_shared<WeakPtrNode>(4);            weakPtrNode3->next = weakPtrNode4;          weakPtrNode4->next = weakPtrNode3;      }      //（1）weakPtrNode 4 release here          {          boost::shared_ptr<WeakPtrNode> sp = (weakPtrNode3->next).lock();          if (sp != nullptr)          {              cout <<  "WeakPtrNode 4 [id:"                                               << setw(4) << setfill( '0' ) << sp->wpNodeId <<  "]"  << endl;          }          else          {              cout <<  "WeakPtrNode 4 Null"  << endl;          }      }   }

根据上面的代码逻辑，在(1)处，weakPtrNode4管理的内容就已经释放，在后续的通过weakPtrNode3->next(weak_ptr)的lock()接口，提升返回的shared_ptr sp会是一个nullptr类型，此时输出的结果将是：

——> Case03_ShareAndWeakPtrLoopRef_5 WeakPtrNode, [wpNodeId:0003] WeakPtrNode, [wpNodeId:0004] ~WeakPtrNode, [wpNodeId:0004] WeakPtrNode 4 Null ~WeakPtrNode, [wpNodeId:0003]