Boost开发指南-3.6weak_ptr

weak_ptr

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

类摘要

template<class T>
class weak_ptr
{
public:weak_ptr(); //构造函数template<class Y> weak_ptr(shared_ptr<Y> const & r);weak_ptr(weak_ptr const & r);~weak_ptr(); //析构函数weak_ptr &operator = (weak_ptr const & r); //赋值long use_count() const; //引用计数bool expired() const; //是否失效指针shared_ptr<T> lock() const; //获取shared_ptrvoid reset(); //重置指针void swap(weak_ptr<T> & b); //交换指针
};

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。

shared_ptr<int> sp(new int(10)); //一个shared_ptr
assert(sp.use_count() == 1);weak_ptr<int> wp(sp); //从shared_ptr创建weak_ptr
assert(wp.use_count() == 1); //weak_ptr不影响引用计数if (!wp.expired()) //判断weak_ptr观察的对象是否失效
{shared_ptr<int> sp2 = wp.lock(); //获得一个shared_ptr*sp2 = 100;assert(wp.use_count() == 2); //退出作用域,sp2自动析构,引用计数减1
}assert(wp.use_count() == 1);
sp.reset(); //shared_ptr失效
assert(wp.expired());
assert(!wp.lock()); //weak_ptr将获得一个空指针

enable_shared_from_this

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

这个解决方案被实现为一个惯用法，在头文件<boost/enable_shared_from_this.hpp>定义了一个助手类enable_shared_from_this<T>，它的声明摘要如下：

template<class T>
class enable_shared_from_this  //辅助类，需要继承使用
public:shared_ptr<T> shared_from_this(); //工厂函数，产生this的shared_ptr

使用的时候只需要让想被shared_ptr管理的类从它派生即可，成员函数shared_from_this()会返回this的shared_ptr。例如：

class self_shared: //一个需要用shared_ptr自我管理的类public enable_shared_from_this<self_shared>
{
public:self_shared(int n) : x(n){}int x;void print(){ cout<< "self_shared : " << x << endl; }
};int main()
{auto sp = make_shared<self_shared>(313);sp->print();auto p = sp->shared_from_this();p->x = 1000;p->print();
}

需要注意的是千万不能对一个普通对象（非shared_ptr管理的对象）使用shared_from_this()获取shared_ptr，例如：

self_shared ss;
auto p = ss.shared_from_this(); //错误

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

enable_shared_from_raw

smart_ptr库在未文档化的头文件<boost/smart_ptr/enable_shared_from_raw .hpp>里提供另外一个与 enable_shared_from_this类似的辅助类enable_shared_from_raw，它不要求对象必须被一个shared_ptr管理，可以直接从一个原始指针创建出shared_ptr。

enable_shared_from_raw的类摘要如下：

class enable_shared_from_raw
{
protected:enable_shared_from_raw();enable_shared_from_raw(enable_shared_from_raw const &);enable_shared_from_raw & operator=(enable_shared_from_raw const &);~enable_shared_from_raw()
private :template<class Y> friend class shared_ptr;template<typenameT>friend boost::shared_ptr<T> shared_from_raw(T *);template<typename T>friend boost::weak_ptr<T> weak_from_raw(T *);
};

enable_shared_from_raw利用了shared_ptr的别名构造函数特性，内部持有一个void*的空指针shared_ptr作为引用计数的观察者，从而达到管理原始指针的目的。

enable_shared_from_raw同样需要继承使用，但它不是模板类，所以不需要指定模板参数，比 enable_shared_from_this写法上要简单一些。它不提供成员函数shared_from_this()，而是用两个friend函数shared_from_raw()和weak_from_raw()完成创建智能指针的工作。

但请注意：在调用shared_from_raw()后，由于存在shared_ptr成员变量的原因，对象内部会有一个shared_ptr的强引用，所以即使其他的 shared_ptr都析构了原始指针也不会被自动删除（因为use_count() >=1）——这使得enable_shared_from_raw用法略微不同于enable_shared_from_this，它可以安全地从一个普通对象而非指针创建出shared_ptr。

示范enable_shared_from_raw用法的代码如下：

#include <boost/smart_ptr/enable_shared_from_raw.hpp>class raw_shared :public boost::enable_shared_from_raw
{
public:raw_shared(){std::cout << "raw_shared ctor" << std::endl;}~raw_shared(){std::cout << "raw_shared dtor" << std::endl;}
};int main()
{raw_shared x; //一个普通对象assert(weak_from_raw(&x).use_count() == 1); //此时无引用,注意要用&取地址auto px = shared_from_raw(&x); //获取shared_ptrassert(px.use_count() == 2); //引用计数为2!
} //对象自动删除

把enable_shared_from_raw应用于原始指针要当心，使用不当有可能造成内存泄漏：

int main()
{auto p = new raw_shared; //创建一个原始指针auto wp = weak_from_raw(p); //获取weak_ptrassert(wp.use_count() == ); //此时无引用auto sp = shared_from_raw(p); //获取shared_ptrassert(sp.use_count() == 2); //引用计数为2!auto sp2 = sp; //拷贝一个shared_ptrauto wp2 = weak_from_raw(p); //获取weak_ptrassert(wp2.use_count() == 3); //引用计数为3
} //对象没有被删除,内存泄露!

如果在代码里的某个时刻使用shared_ptr来管理原始指针——而不是调用shared_from_raw()，那么指针的管理权就会转移到 shared_ptr，从而可以正确地自动销毁，例如：

int main()
{auto p = new raw_shared; //创建一个原始指针decltype(shared_from_raw(p)) spx(p); //使用shared_ptr管理指针... //其他操作
} //对象被自动删除

enable_shared_from_raw的用法比较特殊，实际应用的场景较少，也许这就是它没有在 Boost库里被文档化的原因。

打破循环引用

有的时候代码中可能会出现“循环引用”，这时shared_ptr的引用计数机制就会失效，导致不能正确释放资源，例如：

#include <boost/smart_ptr.hpp>
using namespace boost;class node //一个用于链表节点的类
{
public:~node() //析构函数输出信息{std::cout << "deleted" << std::endl;}typedef shared_ptr<node> ptr_type; //指针类型使用shared_ptrptr_type next; //后继指针
};int main()
{auto p1 = make_shared<node>(); //两个节点对象auto p2 = make_shared<node>();p1->next = p2; //形成循环链表p2->next = p1; assert(p1.use_count() == 2); //每个shared_ptr的引用计数都是2assert(p2.use_count() == 2);} //退出作用域,shared_ptr无法正确析构

上面的代码中两个节点对象互相持有对方的引用，每一个shared_ptr的引用计数都是2，因此在析构时引用计数没有减至0，不会调用删除操作，导致内存泄漏。

这个时候我们就可以使用weak_ptr，因为它不会增加智能指针的引用计数，这样就把原来的强引用改变为弱引用，在可能存在循环引用的地方打破了循环，而在真正需要shared_ptr的时候调用weak_ptr的lock()函数：

class node //一个用于链表节点的类
{
public:~node() //析构函数输出信息{std::cout << "deleted" << std::endl;}typedef weak_ptr<node> ptr_type; //指针类型使用weak_ptrptr_type next; //后继指针
};int main()
{auto p1 = make_shared<node>(); //两个节点对象auto p2 = make_shared<node>();p1->next = p2; //形成循环链表p2->next = p1; //引用使用了weak_ptr所以正常assert(p1.use_count() == 1); //每个shared_ptr的引用计数都是2assert(p2.use_count() == 1); //没有了循环引用if (!p1->next.expired()) //检查弱引用是否有效{auto p3 = p1->next.lock(); //调用lock()获得强引用}} //退出作用域,shared_ptr均正确析构

代码示例

#include <iostream>
//using namespace std;#include <boost/smart_ptr.hpp>
using namespace boost;//void case1()
{shared_ptr<int> sp(new int(10));assert(sp.use_count() == 1);weak_ptr<int> wp(sp);assert(wp.use_count() == 1);assert(!wp.empty());if (!wp.expired()){shared_ptr<int> sp2 = wp.lock();*sp2 = 100;assert(wp.use_count() == 2);}assert(wp.use_count() == 1);sp.reset();assert(wp.expired());assert(!wp.lock());
}//class self_shared :public enable_shared_from_this<self_shared>
{
public:self_shared(int n) :x(n) {}int x;void print(){std::cout << "self_shared:" << x << std::endl;}
};void case2()
{auto sp = make_shared<self_shared>(313);sp->print();auto p = sp->shared_from_this();p->x = 1000;p->print();
}//class node
{
public:~node(){std::cout << "deleted" << std::endl;}typedef weak_ptr<node> ptr_type;//typedef shared_ptr<node> ptr_type;ptr_type next;
};void case3()
{auto p1 = make_shared<node>();auto p2 = make_shared<node>();p1->next = p2;p2->next = p1;assert(p1.use_count() == 1);assert(p2.use_count() == 1);if (!p1->next.expired()){auto p3 = p1->next.lock();}
}//
#include <boost/smart_ptr/enable_shared_from_raw.hpp>class raw_shared :public enable_shared_from_raw
{
public:raw_shared(){std::cout << "raw_shared ctor" << std::endl;}~raw_shared(){std::cout << "raw_shared dtor" << std::endl;}
};void case4()
{raw_shared x;assert(weak_from_raw(&x).use_count() == 1);auto px = shared_from_raw(&x);assert(px.use_count() == 2);auto p = new raw_shared;auto wp = weak_from_raw(p);assert(wp.use_count() == 1);decltype(shared_from_raw(p)) spx(p);auto sp = shared_from_raw(p);//std::cout << sp.use_count() << std::endl;assert(sp.use_count() == 2);//decltype(sp) spx(p);auto sp2 = sp;auto wp2 = weak_from_raw(p);assert(wp2.use_count() == 3);
}//int main()
{case1();case2();case3();case4();
}