智能指针shared_ptr组件的使用

shared_ptr是boost.smart_ptr库中最具价值、最有份量的组成部分。它与scoped_ptr一样包装了new操作符在堆上分配动态对象，但它实现的是引用计数(reference-count)型智能指针，可以被自由地拷贝和赋值，在任意的地方共享它。当引用计数值为0，也即没有代码使用它时它会自动删除被分配资源的对象。

shared_ptr可以安全地放到标准容器中，并弥补了auto_ptr因为转移语义而不能把指针STL容器元素的缺陷。C++历史上出现过很多引用计数型的智能指针，但没有一个比得上boost::shared_ptr的，过去，现在，将来它都是最好的。

类摘要：

template<class T> class shared_ptr{private:    // Borland 5.5.1 specific workaround    typedef shared_ptr<T> this_type;public:    typedef T element_type;    typedef T value_type;    typedef T * pointer;    typedef typename boost::detail::shared_ptr_traits<T>::reference reference;    shared_ptr();    template<class Y>    explicit shared_ptr( Y * p );    template<class Y, class D> shared_ptr(Y * p, D d);    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a );    template<class Y>    explicit shared_ptr(weak_ptr<Y> const & r);    template<class Y>    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag );    template<class Y>    shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() );    shared_ptr( shared_ptr<Y> const & r );    template< class Y >    shared_ptr( shared_ptr<Y> const & r, T * p );    template<class Y>    shared_ptr(shared_ptr<Y> const & r, boost::detail::static_cast_tag);    template<class Y>    shared_ptr(shared_ptr<Y> const & r, boost::detail::const_cast_tag);    template<class Y>    shared_ptr(shared_ptr<Y> const & r, boost::detail::dynamic_cast_tag);    template<class Y>    shared_ptr(shared_ptr<Y> const & r, boost::detail::polymorphic_cast_tag);    template<class Y>    explicit shared_ptr(std::auto_ptr<Y> & r);    template<class Ap>    explicit shared_ptr( Ap r, typename boost::detail::sp_enable_if_auto_ptr<Ap, int>::type = 0 );    shared_ptr & operator=( shared_ptr const & r ) // never throws    template<class Y>    shared_ptr & operator=(shared_ptr<Y> const & r) //never throw    template<class Y>    shared_ptr & operator=( std::auto_ptr<Y> & r );    template<class Ap>    typename boost::detail::sp_enable_if_auto_ptr< Ap, shared_ptr & >::type operator=( Ap r );    shared_ptr( shared_ptr && r );    template<class Y>    shared_ptr( shared_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )    shared_ptr( shared_ptr<Y> && r );    shared_ptr & operator=( shared_ptr && r ); // never throws     template<class Y>    shared_ptr & operator=( shared_ptr<Y> && r ) // never throws    void reset() ;// never throws in 1.30+    template<class Y> void reset(Y * p) // Y must be complete    template<class Y, class D> void reset( Y * p, D d );    template<class Y, class D, class A> void reset( Y * p, D d, A a );    template<class Y> void reset( shared_ptr<Y> const & r, T * p );    reference operator* () const;// never throws    T * operator-> () const; // never throws    T * get() const;// never throws    bool unique() const; // never throws    long use_count(); const // never throws    void swap(shared_ptr<T> & other);// never throws    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const;    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti );    bool _internal_equiv( shared_ptr const & r ) const;private:    template<class Y> friend class shared_ptr;    template<class Y> friend class weak_ptr;    T * px;                     // contained pointer    boost::detail::shared_count pn;    // reference counter};  // shared_ptr

shared_ptr重载了*和->操作符以模仿原始指针的行为，同时提供隐式bool类型转换判断指针是否有效。get()可以得到原始指针，没有提供指针算术操作。它可以正常地拷贝，赋值，也可以进行shared_ptr之间的比较，是最智能的智能指针。

shared_ptr有多种形式的构造函数，应用于各种可能的情形：

1，无参的shared_ptr()创建一个持有空指针的shared_ptr

2，shared_ptr(Y *p)获得指向类型T的指针p的管理权，同时引用计数置为1。这个构造函数要求T类型必须能够转换成Y类型

3，shared_ptr(shared_ptr const &r)从另外一个shared_ptr获得指针的管理权，同时引用计数为1，结果是两个shared_ptr共享一个指针的管理权。

4，shared_ptr(std::auto<Y> &r)从一个auto_ptr获得指针的管理权，引用计数置为1，同时auto_ptr自动失去管理权。

5，operator=赋值操作符可以从另外一个shared_ptr或auto_ptr获得指针的管理权，其行为同构造函数

6，shared_ptr(Y *p,D d)行为类似shared_ptr(Y *p)，但使用参数d指定了析构时的定制删除器，而不是简单的delete。

 

shared_ptr的reset()函数是将引用计数减1，停止对指针的共享，除非引用计数为0，否则不会发生删除操作。带参数的reset()则类似相同形式的构造函数，原指针引用计数减1的同时改为管理另外一个指针。

shared_ptr有两个函数来检查引用计数，unique()在shared_ptr是指针的唯一所有者时返回true（这时的行为类似auto_ptr或scoped_ptr），use_count()返回当前指针的引用计数。不过小心了，use_count()仅仅用于测试或者调试，它不提供高效的操作，而且有时可能是不可用的。但是unique()是可靠的，任何时候都可以用，而且比use_count() == 1速度更快。

shared_ptr支持比较运算，可以测试两个shared_ptr的相等或不相等，比较基于内部保存的指针，相当于a.get() == b.get() 。还可以使用operator<比较大小，同样基于内部保存的指针，但不提供除它以外的比较符，这使得shared_ptr可以被应用于标准关联容器（set和map）:

typedef shared_ptr<string> sp_t;

map<sp_t,int > m; //标准映射容器

sp_t sp(new string("one"));

m[sp] = 111; 

在编写基于虚函数的多态代码时指针的类型转换很有用，比如把一个基类指针转换成一个继承类指针或者反过来（继承类指针转换成基类指针）。但对于shared_ptr不能使用诸如static_cast<T *>(p.get())的形式。这将导致转型后的指针无法再被shared_ptr正确管理。为了支持这种用法，shared_ptr提供了类似的转型函数static_pointer_cast<T>() ,const_pointer_cast<T>, dynamic_pointer_cast<T>类似，但它返回的是转型后的shared_ptr。

例如，下面的代码使用dynamic_pointer_cast把一个shared_ptr<std::exception>向下转型为一个shared_ptr<bad_exception>，然后又用static_pointer_cast重置转为shared_ptr<std::exception>；

shared_ptr<std::exception> sp1(new bad_exception("error"));

shared_ptr<bad_exception> sp2 = dynamic_pointer_cast<bad_exception>(sp1);

shared_ptr<std::exception> sp3 = static_pointer_cast<std::exception>(sp2);

assert(sp3 == sp1);

shared_ptr还支持流输出操作符operator<<，输出内部的指针值，方便调试。

 

使用示例：

#include <iostream>#include <boost/smart_ptr.hpp>using namespace boost;using namespace std;class shared //define a custom class{ public: shared(shared_ptr<int> p):_p(p){} void print() {  cout << "count: " << _p.use_count()       << "  v= " << *_p << endl; } private: shared_ptr<int> _p;};void print_func(shared_ptr<int> p){ cout << "count: " << p.use_count()       << "  v= " << *p << endl;}int main(){ /* /*example1 shared_ptr<int> sp(new int(10));//a smart_ptr pointed to int assert(sp.unique()); //shared_ptr is the only owner of pointer  shared_ptr<int> sp2 = sp; //the second shared_ptr,copy construct assert(sp == sp2 && sp.use_count() == 2);  //Two shared_ptr equal, pointing in the same object, reference counting is 2 *sp2 = 100; //now print *sp2 assert(*sp == 100); sp.reset();// assert(!sp);//sp now is empty cout << "no problem." << endl;     */ /*example2*/ shared_ptr<int> p(new int(100)); shared s1(p),s2(p);//custom shared class object  s1.print(); //3 s2.print();//3  *p = 20; //modify the value of the object which p point to print_func(p);//display use_count 4 s1.print();//3 }

 

运行结果：

count: 3  v= 100
count: 3  v= 100
count: 4  v= 20
count: 3  v= 20

注意，我们没有使用引用方式传递参数，而是直接拷贝，就像是使用一个原始指针，shared_ptr支持这样的用法。

在声明了share_ptr和两个shared类实例后，指针被它们所共享，因此引用计数为3。print_fun()函数内部拷贝了一个shared_ptr对象，因此引用计数再增加1，退出的时候拷贝自动析构，引用计数又恢复到了3