auto_ptr解析

auto_ptr解析

        // TEMPLATE CLASS auto_ptr
template<class _Ty>
    class auto_ptr;

template<class _Ty>
    struct auto_ptr_ref
        {    // proxy reference for auto_ptr copying
    explicit auto_ptr_ref(_Ty *_Right)        // auto_ptr的引用 [8/8/2017 by whg]
        : _Ref(_Right)
        {    // construct from generic pointer to auto_ptr ptr
        }

    _Ty *_Ref;    // generic pointer to auto_ptr ptr
    };

template<class _Ty>
    class auto_ptr
        {    // wrap an object pointer to ensure destruction
public:
    typedef auto_ptr<_Ty> _Myt;                    // 定义auto_ptr<_Ty>模板类型 [8/8/2017 by whg]
    typedef _Ty element_type;                    // 定义模板参数 [8/8/2017 by whg]

    explicit auto_ptr(_Ty *_Ptr = 0) _THROW0()    // 构造函数，指针赋值 [8/8/2017 by whg]
        : _Myptr(_Ptr)
        {    // construct from object pointer
        }

    auto_ptr(_Myt& _Right) _THROW0()            // 构造函数，模板类型赋值 [8/8/2017 by whg]
        : _Myptr(_Right.release())                // 调用release，返回_Myt指针类型 [8/8/2017 by whg]
        {    // construct by assuming pointer from _Right auto_ptr
        }

    auto_ptr(auto_ptr_ref<_Ty> _Right) _THROW0()    // 构造函数，auto_ptr_ref引用赋值 [8/8/2017 by whg]
        {    // construct by assuming pointer from _Right auto_ptr_ref
        _Ty *_Ptr = _Right._Ref;
        _Right._Ref = 0;    // release old
        _Myptr = _Ptr;    // reset this
        }

    template<class _Other>
        operator auto_ptr<_Other>() _THROW0()        //强制转换成auto_ptr<_Other>类型 [8/8/2017 by whg]
        {    // convert to compatible auto_ptr
        return (auto_ptr<_Other>(*this));
        }

    template<class _Other>
        operator auto_ptr_ref<_Other>() _THROW0()    // 强制转成auto_ptr_ref<_Other>类型 [8/8/2017 by whg]
        {    // convert to compatible auto_ptr_ref
        _Other *_Cvtptr = _Myptr;    // test implicit conversion
        auto_ptr_ref<_Other> _Ans(_Cvtptr);
        _Myptr = 0;    // pass ownership to auto_ptr_ref
        return (_Ans);
        }

    template<class _Other>
        _Myt& operator=(auto_ptr<_Other>& _Right) _THROW0()    //释放掉_Right的指向内容，然后情况left的指向，改成right的指向  [8/8/2017 by whg]
        {    // assign compatible _Right (assume pointer)
        reset(_Right.release());
        return (*this);
        }

    template<class _Other>
        auto_ptr(auto_ptr<_Other>& _Right) _THROW0()    // 构造函数，和auto_ptr(_Myt& _Right)差不多？ [8/8/2017 by whg]
        : _Myptr(_Right.release())
        {    // construct by assuming pointer from _Right
        }

    _Myt& operator=(_Myt& _Right) _THROW0()        // =操作符，先释放掉right，清空left，再赋值给left [8/8/2017 by whg]
        {    // assign compatible _Right (assume pointer)
        reset(_Right.release());
        return (*this);
        }

    _Myt& operator=(auto_ptr_ref<_Ty> _Right) _THROW0()    // 重载=操作符，right为auto_ptr_ref [8/8/2017 by whg]
        {    // assign compatible _Right._Ref (assume pointer)
        _Ty *_Ptr = _Right._Ref;
        _Right._Ref = 0;    // release old
        reset(_Ptr);    // set new
        return (*this);
        }

    ~auto_ptr() _NOEXCEPT        //析构函数 [8/8/2017 by whg]
        {    // destroy the object
        delete _Myptr;
        }

    _Ty& operator*() const _THROW0()    // *操作符，返回指针的实体 [8/8/2017 by whg]
        {    // return designated value
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Myptr == 0)
            _DEBUG_ERROR("auto_ptr not dereferencable");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        return (*get());
        }

    _Ty *operator->() const _THROW0()    // ->操作符，返回指针 [8/8/2017 by whg]
        {    // return pointer to class object
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Myptr == 0)
            _DEBUG_ERROR("auto_ptr not dereferencable");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        return (get());
        }

    _Ty *get() const _THROW0()        // 返回指针 [8/8/2017 by whg]
        {    // return wrapped pointer
        return (_Myptr);
        }

    _Ty *release() _THROW0()        // 清空保存的指针 [8/8/2017 by whg]
        {    // return wrapped pointer and give up ownership
        _Ty *_Tmp = _Myptr;
        _Myptr = 0;
        return (_Tmp);
        }

    void reset(_Ty *_Ptr = 0)        // delete先前的内容，然后赋值给新的指针 [8/8/2017 by whg]
        {    // destroy designated object and store new pointer
        if (_Ptr != _Myptr)
            delete _Myptr;
        _Myptr = _Ptr;
        }

private:
    _Ty *_Myptr;    // the wrapped object pointer
    };

　　release函数返回_Ty*类型指针，会将自身的指针置为0。reset函数会先delete掉自身的指针，然后才接收新的指针。
　　如果auto_ptr是另一个auto_ptr赋值构造，则必有一个auto_ptr的指针为0。如下所示：

class MyClass
    {
    public:
        MyClass(int i){    id =i;};
        ~MyClass(){    id = 2;};
        int id;
    };
    MyClass* my =new MyClass(1);
    std::auto_ptr<MyClass> ptr1(my);
    std::auto_ptr<MyClass> ptr2(ptr1);
    int id = ptr1->id;

　　这段代码将在11行crash掉，就是因为构造ptr2会将ptr1内的指针设置为0。生存期结束后，auto_ptr析构函数调用delete释放掉指针0，但不会重复delete。