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();
}
