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

  1.  template<typename _Tp>  
  2.     class auto_ptr  
  3.     {  
  4.     private:  
  5.       _Tp* _M_ptr;   
  6.     public:  
  7.       typedef _Tp element_type;  
  8. //////****构造函数******/  
  9. explicit 
  10.       auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }  
  11.  
  12.       auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }  
  13.  
  14.       template<typename _Tp1>  
  15.         auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }  
  16. /*******重载赋值操作***********/ 
  17. auto_ptr&  
  18.       operator=(auto_ptr& __a) throw()  
  19.       {  
  20.     reset(__a.release());  
  21.     return *this;  
  22.       }  
  23.  
  24.       template<typename _Tp1>  
  25.         auto_ptr&  
  26.         operator=(auto_ptr<_Tp1>& __a) throw()  
  27.         {  
  28.       reset(__a.release());  
  29.       return *this;  
  30.     }  
  31. //********析构****/  
  32.       ~auto_ptr() { delete _M_ptr; }  
  33. /*******成员函数****************/ 
  34. element_type*  
  35.       get() const throw() { return _M_ptr; }  
  36. element_type*  
  37.       release() throw()  
  38.       {  
  39.     element_type* __tmp = _M_ptr;  
  40.     _M_ptr = 0;  
  41.     return __tmp;  
  42.       }  
  43. void  reset(element_type* __p = 0) throw()  
  44.       {  
  45.     if (__p != _M_ptr)  
  46.       {  
  47.         delete _M_ptr;  
  48.         _M_ptr = __p;  
  49.       }  
  50.       }  
  51. /*********以下就是auto_ptr不同于其他智能指针的地方*********/ 
  52. template<typename _Tp1>  
  53.     struct auto_ptr_ref  
  54.     {  
  55.       _Tp1* _M_ptr;  
  56.         
  57.       explicit 
  58.       auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }  
  59.     };  
  60. auto_ptr(auto_ptr_ref<element_type> __ref) throw()  
  61.       : _M_ptr(__ref._M_ptr) { }  
  62.         
  63.       auto_ptr&  
  64.       operator=(auto_ptr_ref<element_type> __ref) throw()  
  65.       {  
  66.     if (__ref._M_ptr != this->get())  
  67.       {  
  68.         delete _M_ptr;  
  69.         _M_ptr = __ref._M_ptr;  
  70.       }  
  71.     return *this;  
  72.       }  
  73.         
  74.       template<typename _Tp1>  
  75.         operator auto_ptr_ref<_Tp1>() throw()  
  76.         { return auto_ptr_ref<_Tp1>(this->release()); }  
  77.  
  78.       template<typename _Tp1>  
  79.         operator auto_ptr<_Tp1>() throw()  
  80.         { return auto_ptr<_Tp1>(this->release()); }  
  81.   };  
  82. }  

 之所以有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的功能。