(转)引领Boost（四）Boost::smart_ptr

引领Boost（四）（Boost::smart_ptr）

作者：梦在天涯　来源：C++博客 　 酷勤网收集　 2007-09-12

摘要

酷勤网

　　std::auto_ptr很多的时候并不能满足我们的要求，比如她不能用在STL的container中。boost的smart_ptr中提供了4种智能指针和2种智能指针数组来作为std::auto_ptr的补充。

一 Boost::smart_Ptr
   
    我们学习C++都知道智能指针，例如STL中的std::auto_ptr，但是为什么要使用智能指针，使用它能带给我们什么好处呢？

最简单的使用智能指针可以不会因为忘记delete指针而造成内存泄露。还有如果我们开发或者使用第三方的lib中的某些函数需要返回指针，这样的返回的指针被client使用的时候，lib就会失去对返回的指针的控制，这样delete的指针的任务一般就会交给调用方client，但是如果client忘记调用delete或是调用的时机不正确，都有可能导致问题，在这种情况下就最好使用智能指针。还有使用智能指针可以保证异常安全，保证程序在有异常抛出时仍然无内存泄露。
   
    std::auto_ptr很多的时候并不能满足我们的要求，比如她不能用在STL的container中。boost的smart_ptr中提供了4种智能指针和2种智能指针数组来作为std::auto_ptr的补充。   
      

    shared_ptr<boost/shared_ptr.hpp> ：使用shared_ptr进行对象的生存期自动管理，使得分享资源所有权变得有效且安全.  (redwolf 注：基于计数器的智能指针。同时，它只能作为单个指针使用，不能指向数组，也不能构造成数组式的指针。)

    scoped_ptr<boost/scoped_ptr.hpp> ： 用于确保能够正确地删除动态分配的对象。scoped_ptr 有着与std::auto_ptr类似的特性，而最大的区别在于它不能转让所有权而auto_ptr可以。事实上，scoped_ptr永远不能被复制或被赋值！scoped_ptr 拥有它所指向的资源的所有权，并永远不会放弃这个所有权。 （redwolf注：在所有权这一点上，类似于c中的void* const ptr;一类声明。不能被复制和赋值是因为它没有提供public形式的复制构造函数和重载=运算符。同shared_ptr一样，它也只能用于单个指针。）

    weak_ptr<boost/weak_ptr.hpp> ：weak_ptr 是 shared_ptr 的观察员。它不会干扰shared_ptr所共享的所有权。当一个被weak_ptr所观察的 shared_ptr 要释放它的资源时，它会把相关的 weak_ptr的指针设为空。 使用此辅助指针一般是防止悬空指针。 ( 悬空指针也称野指针，指的是指向当时不合法的变量地址的指针。比如：未初始化的指针，使用过后释放内存后但没有置空的指针等。这样的指针如果直接或者间接引用的话，一般导致程序的致命错误。)

    intrusive_ptr<boost/intrusive_ptr.hpp> ：shared_ptr的插入式版本，一般不使用，因为需要对使用此指针的类型中增加ref计数功能。但是可以保证不增加指针的大小。

    scoped_array<boost/scoped_array.hpp> ： scoped_array 为数组做了scoped_ptr为单个对象的指针所做的事情：它负责释放内存。 （redwolf注：类似于const类型的vector。）
    shared_array<boost/shared_array.hpp> ： shared_array 用于共享数组所有权的智能指针。一般指向std::vector的shared_ptr提供了比shared_array更多的灵活性，所以一般使用std::vector<shared_ptr>。 （redwolf注：用vector替换行吗？）

二 源码剖析

    通过上面的分析，下面主要介绍我们最常用也最有用的shared_ptr智能指针。（智能指针的实现，其实最重要的是就是重载->和*运算符）

下面是shared_ptr的头文件： (redwolf 注：为什么有的函数有两个版本，一个是模板参数的一个是非模板参数的？)

template< class  Ty>  class  shared_ptr  {
public :
  typedef Ty element_type;

  shared_ptr();
  template< class  Other>
     explicit  shared_ptr(Other *ptr); （redwolf注：强制显示构造）
  template< class  Other,  class  D>
    shared_ptr(Other *ptr, D dtor); （redwolf注：由普通指针构造）
  shared_ptr( const  shared_ptr& sp); （redwolf注：可以复制）
  template< class  Other>
    shared_ptr( const  shared_ptr<Other>& sp);
  template < class  Other>
    shared_ptr( const  weak_ptr<Other>& wp); （redwolf注：由weak_ptr构造，相当于     类型转换）
  template< class  Other>
    shared_ptr( const  std::auto_ptr<Other>& ap); （redwolf注：类型转换）
  ~shared_ptr();

  shared_ptr&  operator =( const  shared_ptr& sp); （redwolf注：可以赋值）
  template< class  Other>
    shared_ptr&  operator =( const  shared_ptr<Other>& sp);
  template< class  Other>
    shared_ptr&  operator =(auto_ptr<Other>& ap);

   void  swap(shared_ptr& s);
   void  reset();
  template< class  Other>
     void  reset(Other *ptr);
  template< class  Other,  class  D>
     void  reset(Other *ptr, D dtor);

  Ty * get ()  const ;
  Ty&  operator *()  const ;
  Ty * operator ->()  const ;
   long  use_count()  const ;
   bool  unique()  const ;
   operator  boolean-type()  const ;
  };

 1 ）构造函数，可以通过一般指针，std::auto_ptr,boost::shared_ptr,boost::weak_ptr来构造， 还可以构造的时候指定如果delete指针 （redwolf注：用户自己提供析构器，智能指针在删除时不调用默认的析构器（deleter）。析构器并不是析构函数。） 。
 2）拷贝构造函数
 3）get()， 得到boost::shared_ptr所封装的指针。
 4）*，得到boost::shared_ptr所封装指针的值。
 5)->,用于直接调用指针的成员。
 6）reset(), 用于重设boost::shared_ptr,或设为空。
 7) swap(),  用于交换2个boost::shared_ptr.
 8) use_count(), use_count 函数返回指针的引用计数。
 9) unique(),这个函数在shared_ptr是它所保存指针的唯一拥有者时返回 true ；否则返回 false。 unique 不会抛出异常。

 

三 实例

 1 ）构造，拷贝构造，赋值，get，*，->, reset, swap:

#include "boost/shared_ptr.hpp"
#include <cassert>
#include <iostream>

class  A 
{  
    boost::shared_ptr< int > no_;
public : 
    A(boost::shared_ptr< int > no) : no_(no)  {} 
     void  value( int  i)  { *no_=i;  }
};
class  B 
{  
    boost::shared_ptr< int > no_;
public :  
    B(boost::shared_ptr< int > no) : no_(no)  {}  
     int  value()  const   {   return  *no_;  }
};
struct  deleter
{
     void   operator ()( int  *i)
     {
        std::cout << "destroying resource at"
            << ( void *)i << '\n';
        delete i;
    }
};
struct  S
{
     int  member;
};

int  main() 
{  
     // test for constructor
    boost::shared_ptr< int > sp;   
    boost::shared_ptr< int > sp2(( int *)0);
     {
    boost::shared_ptr< int > sp3( new   int (3), deleter());
    }

    std::auto_ptr< int > temp( new   int (10));
    boost::shared_ptr< int > sp4(temp);

    boost::shared_ptr< int > temp2( new   int (14));  
    boost::shared_ptr< int > sp5(temp2);


     // test for using the shared_ptr(get,->,*)
     int  *ip =  new   int (3);                   
    std::cout << ( void *)ip << '\n';             
    boost::shared_ptr< int > sp6(ip);                
    std::cout << ( void *)sp6. get  () << '\n';       

     int  *ip2 =  new   int (3);               
    std::cout << ( void *)ip2 << '\n';         
    boost::shared_ptr< int > sp7(ip2);           
    std::cout << *sp7 << '\n';              
    std::cout << ( void *)&*sp7 << '\n';        

    S *s =  new  S;                           
    s->member = 4;                           
    boost::shared_ptr<S> sp8(s);                    
    std::cout << sp8 -> member << '\n';  

     // test for assign 
    std::cout << std::boolalpha;
    boost::shared_ptr< int > sp9( new   int (0));  
    boost::shared_ptr< int > sp10 = sp9;
    std::cout << "sp0 == sp1:" << (sp9 == sp10) << '\n';  
    std::cout << "sp0 != sp2:" << (sp9 != sp10) << '\n';

     // test funcion: reset and swap
    boost::shared_ptr< int > sp11 ( new   int (0));
    boost::shared_ptr< int > sp12 ( new   int (1));
    sp11. swap (sp12);
    std::cout<<*sp11<<*sp12<<std::endl;
    boost::swap(sp11, sp12);
    std::cout<<*sp11<<*sp12<<std::endl;

    boost::shared_ptr< int > sp0; 
    sp0.reset(); 
    boost::shared_ptr< int > sp01( new   int (1));
    std::cout << *sp01 <<std::endl;
    sp01.reset();
     //std::cout << *sp01 <<std::endl; //error
    sp01.reset( new   int (100));
    std::cout << *sp01 <<std::endl;
    


     // test for query shared_ptr's state (use_count,unique)
    typedef boost::shared_ptr< int > spi;
    spi sp13 ;                       
    std::cout << "empty object: " << sp13.use_count() << '\n';
     spi sp14 ((int *)0);               
    std::cout << "null pointer: " << sp14.use_count() << '\n';
    spi sp15 ( new   int );               
    std::cout << "one object: " << sp15.use_count() << '\n';
     {
        spi sp16(sp15);                    
        std::cout << "two objects: " << sp15.use_count() << '\n';
        std::cout << "two objects: " << sp16.use_count() << '\n';
    }
    std::cout << "one object: " << sp15.use_count() << '\n';
    
    std::cout << std::boolalpha;
    spi sp17;                       
    std::cout << "empty object: " << sp17.unique() << '\n';
    spi sp18(( int  *)0);              
    std::cout << "null pointer: " << sp18.unique() << '\n';
    spi sp19( new   int );              
    std::cout << "one object: " << sp19.unique() << '\n';
     { 
        spi sp20(sp19);                     
        std::cout << "two objects: " << sp19.unique() << '\n';
        std::cout << "two objects: " << sp20.unique() << '\n';
    } 
    std::cout << "one object: " << sp19.unique() << '\n';

}

 

 2) 在STL容器中的使用: 

#include "boost/shared_ptr.hpp"
#include <vector>
#include <iostream>
class  A 
{
public :  
     virtual   void  sing()
     {
        std::cout <<"A::sing" <<std::endl;
    }
protected :  
     virtual  ~A() 
     {std::cout<<"~A"<<std::endl;};
};
class  B :  public  A 
{
public :  
     virtual   void  sing() 
     {   
        std::cout << "B:sing"<<std::endl; 
    }
     virtual  ~B()
     {std::cout<<"~B"<<std::endl;}
};
boost::shared_ptr<A> createA()
{ 
    boost::shared_ptr<A> p( new  B()); 
     return  p;
}
int  main() 
{  
    typedef std::vector<boost::shared_ptr<A> > container_type; 
    typedef container_type::iterator iterator; 
    container_type container;
     for  ( int  i=0;i<10;++i) 
     {   
        container.push_back(createA()); 
    }  
    std::cout << "The choir is gathered: \n"; 
    iterator end=container.end(); 
     for  (iterator it=container.begin();it!=end;++it)
     {    (*it)->sing(); }
}