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 = 0) : _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 = 0;    // 将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 = 0;
        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 = 0;    // 将pa1的Ref指针指向空
        reset(_Ptr);    // 将pa2的_Myptr指向pa1
        return (*this);
    }

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

    _Ty& operator*() const    //重载*
    {
        if (_Myptr == 0)
        {
            _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 = 0;        //再讲pa1的指针指向空
        return (_Tmp);    //    返回Tmp即原来pa1指向的地址
    }

    void reset(_Ty *_Ptr = 0)    //将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(10));
    auto_ptr<int>pa1(pa);
    cout << *pa1<<endl;
    auto_ptr<int> pa2;
    pa2 = pa1;
    cout << *pa2 << endl;
    auto_ptr_ref<int> par1(new int(20));
    auto_ptr<int> pa3(par1);
    cout << *pa3 << endl;
    return 0;
}

运行结果：

10
10
20