auto_prt的VS版本源码剖析

通过对VC版本的auto_ptr的源代码得知VC版本还有一点小缺陷，又对VS版本的auto_ptr做了一些剖析，具体代码和注释如下：

 //假设全局pa2都是用pa1来构造
 //如：pa2(pa1)、pa2=pa1

 template<class _Ty>    //auto_ptr类声明
 class auto_ptr;

 template<class _Ty>
 struct auto_ptr_ref    //auto_ptr的辅助类
 {
     explicit auto_ptr_ref(_Ty *_Right): _Ref(_Right)
     {}
     _Ty *_Ref;
 };

 template<class _Ty>
 class auto_ptr//auto_ptr类
 {
 public:
     typedef auto_ptr<_Ty> _Myt;    //管理类的类型
     typedef _Ty element_type;    //被管理元素的类型

     explicit auto_ptr(_Ty *_Ptr = ) : _Myptr(_Ptr)    //构造
     {}    //从原始指针中获取控制权

     //若pa2(pa1);
     auto_ptr(_Myt& _Right) : _Myptr(_Right.release())    //拷贝构造
     {}

     //若：pa2(pa1)
     auto_ptr(auto_ptr_ref<_Ty> _Right)
     {
         // 用右值来构造
         _Ty *_Ptr = _Right._Ref;    //将pa1的指针保存在Ptr中
         _Right._Ref = ;    // 将pa1的指针指向空
         _Myptr = _Ptr;    // 将pa2的地址指向pa1的地址
     }

     template<class _Other>
     operator auto_ptr<_Other>()        //转换为可转换的类型
     {
         return (auto_ptr<_Other>(*this));
     }

     template<class _Other>
     operator auto_ptr_ref<_Other>()        //隐式类型转换，将auto_ptr类型指针转换为auto_ptr_ref类型
     {
         _Other *_Cvtptr = _Myptr;
         auto_ptr_ref<_Other> _Ans(_Cvtptr);
         _Myptr = ;
         return (_Ans);
     }

     template<class _Other>
     _Myt& operator=(auto_ptr<_Other>& _Right)    //针对可转换为 _Ty* 类型的 _Other* 类型的拷贝函数
     {
         reset(_Right.release());
         return (*this);
     }

     template<class _Other>    //特定类型构造函数
     auto_ptr(auto_ptr<_Other>& _Right) : _Myptr(_Right.release())
     {}    //针对可转换为 _Ty* 类型的 _Other* 类型的构造函数

     //若:pa2=pa1
     _Myt& operator=(_Myt& _Right)    //拷贝赋值函数
     {
         reset(_Right.release());
         return (*this);
     }

     //若：pa2=pa1
     _Myt& operator=(auto_ptr_ref<_Ty> _Right)    //将一个 auto_ptr_ref 类型的变量赋值给 *this
     {
         _Ty *_Ptr = _Right._Ref;    //将pa1的Ref指针赋值给pa2的_Ptr指针
         _Right._Ref = ;    // 将pa1的Ref指针指向空
         reset(_Ptr);    // 将pa2的_Myptr指向pa1
         return (*this);
     }

     ~auto_ptr()     //析构
     {
         delete _Myptr;    //析构指针所指向的内容
     }

     _Ty& operator*() const    //重载*
     {
         if (_Myptr == )
         {
             _DEBUG_ERROR("auto_ptr not dereferencable");
         }
         return (*get());
     }

     _Ty *operator->() const        //重载->
     {
         return (get());
     }

     _Ty *get() const    //用来返回_Myptr的地址
     {
         return (_Myptr);
     }

     _Ty *release()    //将一个对象的_Myptr记住，再指向空，然后再把其记住的地址返回
     {
         _Ty *_Tmp = _Myptr;    //先将pa1的指针用Tmp保存，
         _Myptr = ;        //再讲pa1的指针指向空
         return (_Tmp);    //    返回Tmp即原来pa1指向的地址
     }

     void reset(_Ty *_Ptr = )    //将this的_Myptr指向传进来的指针的地址
     {
         if (_Ptr != _Myptr)    //如果pa1“以前的”(pa1在release()中被指向空，就是返回的那个Tmp用来记住pa1以前的那个地址)那个地址所指向的地址不等于pa2的地址
             delete _Myptr;    //先析构pa2所指向的地址

         _Myptr = _Ptr;        //再将pa2地址指向返回来的pa1的老地址
     }

 private:
     _Ty *_Myptr;
 };

测试代码：

 int main(int argc, char* argv[])
 {
     auto_ptr<int> pa(new int());
     auto_ptr<int>pa1(pa);
     cout << *pa1<<endl;
     auto_ptr<int> pa2;
     pa2 = pa1;
     cout << *pa2 << endl;
     auto_ptr_ref<int> par1(new int());
     auto_ptr<int> pa3(par1);
     cout << *pa3 << endl;
     return ;
 }

运行结果：

10
10
20