auto_ptr中的auto_ptr_ref

先看看类auto_ptr的内部实现机制：
 

 
 
 template<typename _Tp>  
    class auto_ptr  
    {  
    private:  
      _Tp* _M_ptr;   
    public:  
      typedef _Tp element_type;  
//****构造函数******/  
explicit 
      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }  
 
      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }  
 
      template<typename _Tp1>  
        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }  
/*******重载赋值操作***********/ 
auto_ptr&  
      operator=(auto_ptr& __a) throw()  
      {  
    reset(__a.release());  
    return *this;  
      }  
 
      template<typename _Tp1>  
        auto_ptr&  
        operator=(auto_ptr<_Tp1>& __a) throw()  
        {  
      reset(__a.release());  
      return *this;  
    }  
//********析构****/  
      ~auto_ptr() { delete _M_ptr; }  
/*******成员函数****************/ 
element_type*  
      get() const throw() { return _M_ptr; }  
element_type*  
      release() throw()  
      {  
    element_type* __tmp = _M_ptr;  
    _M_ptr = 0;  
    return __tmp;  
      }  
void  reset(element_type* __p = 0) throw()  
      {  
    if (__p != _M_ptr)  
      {  
        delete _M_ptr;  
        _M_ptr = __p;  
      }  
      }  
/*********以下就是auto_ptr不同于其他智能指针的地方*********/ 
template<typename _Tp1>  
    struct auto_ptr_ref  
    {  
      _Tp1* _M_ptr;  
        
      explicit 
      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }  
    };  
auto_ptr(auto_ptr_ref<element_type> __ref) throw()  
      : _M_ptr(__ref._M_ptr) { }  
        
      auto_ptr&  
      operator=(auto_ptr_ref<element_type> __ref) throw()  
      {  
    if (__ref._M_ptr != this->get())  
      {  
        delete _M_ptr;  
        _M_ptr = __ref._M_ptr;  
      }  
    return *this;  
      }  
        
      template<typename _Tp1>  
        operator auto_ptr_ref<_Tp1>() throw()  
        { return auto_ptr_ref<_Tp1>(this->release()); }  
 
      template<typename _Tp1>  
        operator auto_ptr<_Tp1>() throw()  
        { return auto_ptr<_Tp1>(this->release()); }  
  };  
}  

 之所以有auto_ptr_def，主要是因为auto_ptr的特性，auto_ptr注重对所指对象的拥有权，不能够有两个或两个以上的auto_ptr类型的指针同时指向一个对象，这就使得其拷贝构造函数的形参是引用类型，而非常引用。于是就出现了这样的问题：
auto_ptr<int>  ptr2( auto_ptr<int>( new int(1) ) );语句不能够通过编译，因为
auto_ptr<int>( new int(1) )是个right-Value，对右值进行引用是非法的；也许会有人想为什么不把拷贝构造函数实现能这样：
auto_ptr(auto_ptr __a) throw() : _M_ptr(__a.release()) { }-----------（1）
这样就会和
auto_ptr(auto_ptr&  __a) throw() : _M_ptr(__a.release()) { }---------（2）
重载错误问题，但是如果只保留（1），那auto_ptr强调对资源拥有权的特性就会消失了，还好Bill Gibbons和Greg ColvinBill Gibbons和Greg Colvin利用模板和重载的差别引入了auto_ptr_ref，
auto_ptr(auto_ptr_ref<element_type> __ref) throw()
      : _M_ptr(__ref._M_ptr) { }-------------------------（3）
是可以和（2）重载共存的，当然auto_ptr  ptr(auto_ptr<int>(new int(1)));可以通过编译了（调用（3）拷贝构造函数）。
同理：auto_ptr ptr = auto_ptr<int>(new int(1))能通过编译也是借助于auto_ptr_ref的功能。

本文出自 “东方快翔” 博客，请务必保留此出处http://hustluy.blog.51cto.com/1792080/502132