Learning boost 5
Smart ptr
Boost中提供的5类智能指针。分别是：
l scoped_ptr 独占的指针
l scoped_array 独占的数组
l shared_ptr 引用计数指针
l shared_array 引用计数数组
l weak_ptr shared_ptr的一个弱指针（不参与引用计数）
l intrusive_ptr 自定义的引用计数指针
scoped_ptr和scoped_array
对于scoped_ptr和scoped_array是不可以拷贝构造和赋值的（拷贝构造函数和operator=都是私有成员）。所以它们不像auto_ptr那样传递指针的拥有权，而是独占拥有权，直至对象的销毁（当scoped_ptr和scropted_array析构的时候，所指向的对象也会被析构）。
构造：
scoped_ptr<int> a(new int);
scoped_ptr<int> b;
scoped_array<int> c(new int[100]);
scoped_array<int> d;
scoped_ptr使用new T或者是NULL来初始化对象。scoped_array使用new T[]或者NULL来初始化对象。
它们的默认构造函数，是使用NULL来初始化。
访问：
scoped_ptr重载了operator*和operator->操作符，而scoped_array重载了operator[]下标运算符。通过这几个操作符来操作它们所指向的对象。它们都可以通过T* get()成员函数得到原始的指针。
例如：
scoped_array<char> str(new char[100]);
strcpy(str.get(),"hello");
cout<<str[0]<<str[4]<<endl;//输出 ho
void reset(T * p = 0)
reset用于重置指针指向的对象，当调用reset的时候scoped_ptr或scoped_array会先删除原来指向的对象（如果不是指向NULL的话）。reset的参数和它们构造函数的要求是一样的，必须是new T（或new T[]）或者是NULL。
swap
swap全局函数和swap成员函数，交换两个智能指针指向的对象。例如：
scoped_ptr<int> a(new int);//a指向一个int
scoped_ptr<int> b;//b指向NULL
swap(a,b);//这时，a指向NULL，b指向一个int
bool
scoped_ptr和scoped_array可以隐式的转换为bool类型，当指向NULL的时候返回false，否则返回true。
类型
scoped_ptr<T>和scoped_array<T>中的类型T不能是void类型。
并且scoped_ptr<T>和scoped_ptr<U>不存在类型转换，即使T和U是可以转换的，scoped_ptr<T>和scoped_ptr<const T>也不能转换。
shared_ptr和shared_array
shared_ptr和shared_array是引用计数的智能指针。
下面仅仅介绍shared_ptr的使用。
构造：
对于shared_ptr<T>来说一共有6个构造函数：
shared_ptr(Y * p);
最普通的构造函数，p一定是一个new Y的指针或NULL。注意这里p的类型是Y*，而不是shared_ptr<T>中的T*，所以p一定要存在一个到T*的类型转换。同时shared_ptr会记住p的类型是Y，当p所指向的对象要被析构的时候，shared_ptr会使用正确的析构函数（Y类型的析构函数，而不是T类型的析构函数）。例如：
struct A
{
A(){cout<<"A construct"<<endl;}
~A(){cout<<"A destory"<<endl;}
};
int main()
{
shared_ptr<void> a(new A);
return 0;
}
/*
程序输出：
A construct
A destroy
这就说明A被正确的析构的，并不因为shared_ptr<void>的void而不能析构A，例如：
void del(void *p){delete p;}这就是错的
*/
shared_ptr(Y * p,D d);
同上。d是一个仿函数，用来析构p的，例如：
template <class T>
void my_delete(T * p)
{
delete p;
}
int main()
{
shared_ptr<void> a(new A,my_delete<A>);
return 0;
}
shared_ptr(shared_ptr<Y> const & r);
拷贝构造函数，注意也存在类型转换哦。
shared_ptr(weak_ptr<Y> const & r);
虽然weak_ptr不参与引用计数，但是shared_ptr会的。
shared_ptr(std::auto_ptr<Y> & r);
这时r就指向NULL了。
重置 reset：
void reset();
void reset(Y * p);
void reset(Y * p,D d);
shared_ptr<T> & operator=(shared_ptr<T> const & r);
shared_ptr<T> & operator=(shared_ptr<Y> const & r);
shared_ptr<T> & operator=(std::auto_ptr<Y> & r);
使原来shared_ptr指向的对象引用计数减一，并指向另一个对象，类似于重新构造，所以它们的参数和构造函数一样。
引用计数成员函数：
long use_count();返回引用计数
bool unique();返回use_count()==1
其它：
bool类型转换，operator==，operator!=，operator<，swap，get，流输出（输出指针地址）
D* get_deleter()得到deleter，用来析构对象的仿函数指针。
类型转换：
shared_ptr<T> static_pointer_cast<T>(shared_ptr<U> const & r);
shared_ptr<T> const_pointer_cast<T>(shared_ptr<U> const & r);
shared_ptr<T> dynamic_pointer_cast<T>(shared_ptr<U> const & r);
以上是类似于c++类型转换的一些函数。由于shared_ptr支持指针的类型转换，所以shared_ptr可以保存void指针，也可以向基类指针的转换。这点，scoped_ptr就不可以！
Weak_ptr
weak_ptr是对shared_ptr的一个访问者，weak_ptr不参与shared_ptr的引用计数，也不会删除所指向的对象。同时，当对象被shared_ptr删除后，weak_ptr就是无效的了。
使用weak_ptr，而不使用T*这样的c++指针的原因是：weak_ptr是可以转换成shared_ptr参与引用计数，而T*不可以（只有new T出来的指针才可以构造shared_ptr）。也就是说，weak_ptr虽然不参与引用计数，但是引用计数这套机制还是存在的，当需要转换成shared_ptr的时候就把这套机制传给shared_ptr。否则的话，使用T*构造shared_ptr的话，相当于有两套机制来管理引用计数，那么一个shared_ptr可能指向无效的对象（对象被另一套引用计数机制删除了）。
构造：
weak_ptr();//构造的weak_ptr指向NULL
weak_ptr(weak_ptr const & r);//拷贝构造函数
weak_ptr(weak_ptr<Y> const & r);//类型转换的构造函数
weak_ptr(shared_ptr<Y> const & r);//通过shared_ptr构造，支持类型转换
weak_ptr & operator=(weak_ptr const & r);//赋值运算符的重载
weak_ptr & operator=(weak_ptr<Y> const & r);//类型转换
weak_ptr & operator=(shared_ptr<Y> const & r);//。。。
转换成shared_ptr:
shared_ptr<T> lock();//lock成员函数，通过weak_ptr构造shared_ptr
或者可以使用shared_ptr的构造函数。请参考上面shared_ptr的构造函数。
引用计数：
long use_count();//返回引用计数，虽然不参与引用计数，但是察看还是可以的
bool expired();//返回use_count()==0
其它：
void reset();//重置为NULL
swap成员函数,swap全局函数,operator<重载
intrusive_ptr
intrusive_ptr字面上的意思是侵入式指针，其实就是把引用计数的机制留给使用者来定义。比如windows中的COM对象有自己的一套引用计数机制，那么就可以使用intrusive_ptr来管理引用计数，intrusive_ptr会在适当的时候增加和减少引用计数。
使用intrusive_ptr需要自定义以下两个函数：
void intrusive_ptr_add_ref(T * p);//当增加引用计数时，intrusive_ptr调用
void intrusive_ptr_release(T * p);//当减少引用计数时，intrusive_ptr调用
对于intrusive_ptr我就不多说了，请看下面的一个例子吧。
#include<iostream>
#include <boost/intrusive_ptr.hpp>
using namespace std;
using namespace boost;
struct MyObj
{
int * ref_count;//引用计数
MyObj()
{
ref_count=new int(0);
cout<<"MyObj construct"<<endl;
}
~MyObj()
{
cout<<"MyObj destory"<<endl;
}
};
void intrusive_ptr_add_ref(MyObj * p)
{
cout<<"Add Ref"<<endl;
++(*(p->ref_count));
}
void intrusive_ptr_release(MyObj * p)
{
cout<<"Release"<<endl;
if (--(*(p->ref_count))==0)
delete p;
}
void use(intrusive_ptr<MyObj> obj)//using obj
{
}
int main()
{
intrusive_ptr<MyObj> obj(new MyObj);
intrusive_ptr<MyObj> obj2=obj;
use(obj2);
return 0;
}
一些总结
除了scoped_ptr和scoped_array不可以作为STL容器的成员外，其它的都可以。
除了通过成员函数T*get()之外，还可以使用全局函数get_pointer得到原始指针
T * get_pointer(scoped_ptr<T> const & p);等等。
都可以隐式的转换为bool类型。
等等等等。。。。
