[内存管理]智能指针的好帮手weak_ptr

灰太狼 2022-08-19 15:13 120阅读 0赞

原文链接：http://blog.csdn.net/ajioy/article/details/7377099

weak\_ptr是为配合shared\_ptr而引入的一种智能指针，它更像是shared\_ptr的一个助手，而不是智能指针，因为它不具有普通指针的行为，没有重载operator\*和operator->，它的最大作用在于协助shared\_ptr，像旁观者那样观测资源的使用情况。

类摘要：

**\[cpp\]** [view plain][] [copy][view plain]

1.  **template**<**class** T> **class** weak\_ptr\{ 
2.  **public**: 
3.   weak\_ptr(); 
4.  **template**<**class** Y> weak\_ptr(shared\_ptr<Y> **const** & r); 
5.   weak\_ptr(weak\_ptr **const** & r); 
6.  
7.   ~weak\_ptr(); 
8.   weak\_ptr & operator=(weak\_ptr **const** &r); 
9.  
10. **long** use\_count() **const**; 
11. **bool** expired() **const**; 
12.  shared\_ptr<T> lock() **const**; 
13. 
14. **void** reset(); 
15. **void** swap(weak\_ptr<T> &b); 
16. \};

weak\_ptr是一个“弱”指针，但它能够完成一些特殊的工作，足以证明它的存在价值。

weak\_ptr被设计为与shared\_ptr共同工作，可以从一个shared\_ptr或者另一个weak\_ptr对象构造，获得资源的观测权。但weak\_ptr没有共享资源，它的构造不会引起指针引用计数的增加。同样，在weak\_ptr析构时也不会导致引用计数的减少，它只是一个静静地观察者。

使用weak\_ptr的成员函数use\_count()可以观测资源的引用计数，另一个成员函数expired()的功能等价于use\_count() == 0，但更快，表示观测的资源（也就是shared\_ptr管理的资源）已经不复存在了。

weak\_ptr 没有重载operator\*和->，这是特意的，因为它不共享指针，不能操作资源，这是它弱的原因。但它可以使用一个非常重要的成员函数lock()从被观测的shared\_ptr获得一个可用的shared\_ptr对象，从而操作资源。当expired() == true的时候，lock()函数将返回一个存储空指针的shared\_ptr。

使用示例：

**\[cpp\]** [view plain][] [copy][view plain]

1.  **int** main()\{ 
2.   shared\_ptr<**int**> sp(**new****int**(10)); 
3.   assert(sp.use\_count() == 1); 
4.  //create a weak\_ptr from shared\_ptr
5.   weak\_ptr<**int**> wp(sp); 
6.  //not increase the use count
7.   assert(sp.use\_count() == 1); 
8.  //judge wp is invalid
9.  //expired() is equivalent with use\_count() == 0
10. **if**(!wp.expired())\{ 
11.  shared\_ptr<**int**> sp2 = wp.lock();//get a shared\_ptr
12.  \*sp2 = 100; 
13.  assert(wp.use\_count() == 2); 
14.  cout << \*sp2 << endl; 
15.  \}//out of scope,sp2 destruct automatically,use\_count()--;
16.  assert(wp.use\_count() == 1); 
17.  sp.reset();//shared\_ptr is invalid
18.  assert(wp.expired()); 
19.  assert(!wp.lock()); 
20. \}

获得this的shared\_ptr

weak\_ptr的一个重要用途是获得this指针的shared\_ptr,使对象自己能够生产shared\_ptr管理自己：对象使用weak\_ptr观测this指，这并不影响引用计数，在需要的时候就调用lock()函数，返回一个符合要求的shared\_ptr使外界使用。

这个解决方案被实现为一个惯用法，在头文件<booost/enable\_shared\_from\_this.hpp>定义了一个助手类enable\_shared\_from\_this<T>，其声明如下：

**\[cpp\]** [view plain][] [copy][view plain]

1.  **template**<**class** T> 
2.  **class** enable\_shared\_from\_this 
3.  \{ 
4.  **public**: 
5.   shared\_ptr<T> shared\_from\_this(); 
6.  \}

使用的时候只需要让想被shared\_ptr管理的类从它继承即可，成员函数shared\_from\_this()会返回this的shared\_ptr

使用示例：

**\[cpp\]** [view plain][] [copy][view plain]

1.  \#include <iostream>
2.  \#include <boost/smart\_ptr.hpp>
3.  \#include <boost/enable\_shared\_from\_this.hpp>
4.  \#include <boost/make\_shared.hpp>
5.  **using****namespace** boost; 
6.  **using****namespace** std; 
7.  **class** self\_shared: 
8.  **public** enable\_shared\_from\_this<self\_shared>\{ 
9.  **public**: 
10.  self\_shared(**int** n):x(n)\{\} 
11. **int** x; 
12. **void** print()\{ 
13.  cout << "self\_shared:" << x << endl; 
14.  \} 
15. \}; 
16. **int** main()\{ 
17.  shared\_ptr<self\_shared> sp = 
18.  make\_shared<self\_shared>(315); 
19.  sp->print(); 
20.  shared\_ptr<self\_shared> p = sp->shared\_from\_this(); 
21.  p->x = 100; 
22.  p->print(); 
23. 
24. \}

运行结果：

self\_shared:315  
self\_shared:100

需要注意的是千万不能从一个普通对象（非shared\_ptr）使用shared\_from\_this ()获取shared\_ptr，如

self\_shared ss;

shaerd\_ptr<self\_shared> p = ss.shared\_from\_this();//error

这样虽然语法上能通过，编译也无问题，但在运行时会导致shared\_ptr析构时企图删除一个栈上分配的对象，发生未定义行为。

关于intrusive\_ptr

intrusive\_ptr是一个侵入式的引用计数型指针，它可以用于以下情形：

对内存占用的要求非常严格，要求必须与原始指针一样；

现存代码已经有了引用计数机制管理的对象。

boost库不推荐intrusive\_ptr，因为shared\_ptr已经非常强大且灵活，工作得足够好，可以满足绝大部分（99.99%）的需要。

如果有兴趣，可以自行翻阅boost文档。