Boost开发指南-3.6weak

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_ptr
   void 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_ptr
	assert(px.use_count() == 2); //引用计数为2!
} //对象自动删除

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

int main()
{
	auto p = new raw_shared; //创建一个原始指针

	auto wp = weak_from_raw(p); //获取weak_ptr
	assert(wp.use_count() == ); //此时无引用

	auto sp = shared_from_raw(p); //获取shared_ptr
	assert(sp.use_count() == 2); //引用计数为2!

	auto sp2 = sp; //拷贝一个shared_ptr
	auto wp2 = weak_from_raw(p); //获取weak_ptr
	assert(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_ptr
	ptr_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的引用计数都是2
	assert(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_ptr
	ptr_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的引用计数都是2
	assert(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();
}