1 autp_ptr(C++11之前)

功能简单，源代码简单，所以直接分析源代码（有部分格式改动）

可以知道这是一个模版类（声明方法为auto_ptr<T>）：

首先是类需要用到的一些东西

template<class _Ty> //前向声明
class auto_ptr;

template<class _Ty>
struct auto_ptr_ref
{
explicit auto_ptr_ref(_Ty *_Right)
    : _Ref(_Right){ }

_Ty *_Ref;
};

auto_ptr_ref是一个存储普通指针的结构体，用于下面代码的传值等等。

接下来就是整个类了

template<class _Ty> //模版类型
class auto_ptr
{
public:
    typedef auto_ptr<_Ty> _Myt; //typedef不表
    typedef _Ty element_type;

    explicit auto_ptr(_Ty *_Ptr = 0) _THROW0()  //构造函数
        : _Myptr(_Ptr){ }

    auto_ptr(_Myt& _Right) _THROW0()    //拷贝构造函数（控制权转移，原指针就没用了）
        : _Myptr(_Right.release()){ }

    auto_ptr(auto_ptr_ref<_Ty> _Right) _THROW0()    //也是拷贝构造函数，控制权同样会发生转移
    {
        _Ty *_Ptr = _Right._Ref;
        _Right._Ref = 0;
        _Myptr = _Ptr;
    }

    template<class _Other>
    operator auto_ptr<_Other>() _THROW0()
    {
        return (auto_ptr<_Other>(*this));
    }

    template<class _Other>
    operator auto_ptr_ref<_Other>() _THROW0()
    {
        _Other *_Cvtptr = _Myptr;
        auto_ptr_ref<_Other> _Ans(_Cvtptr);
        _Myptr = 0;
        return (_Ans);
    }

    template<class _Other>
    _Myt& operator=(auto_ptr<_Other>& _Right) _THROW0()
    {
        reset(_Right.release());
        return (*this);
    }

    template<class _Other>
    auto_ptr(auto_ptr<_Other>& _Right) _THROW0()
        : _Myptr(_Right.release()){ }

    _Myt& operator=(_Myt& _Right) _THROW0() //赋值符重载，一样是控制权转移
    {
        reset(_Right.release());
        return (*this);
    }

    _Myt& operator=(auto_ptr_ref<_Ty> _Right) _THROW0()
    {
        _Ty *_Ptr = _Right._Ref;
        _Right._Ref = 0;    // release old
        reset(_Ptr);    // set new
        return (*this);
    }

    ~auto_ptr() _NOEXCEPT
    {   // destroy the object
        delete _Myptr;
    }

    _Ty& operator*() const _THROW0()
    {
 #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()
    {
 #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()  //获得内部的指针，可以用来检测智能指针指向的地方是不是有效的
    {
        return (_Myptr);
    }

    _Ty *release() _THROW0()    //将当前保存的普通指针删除并返回这个指针的值
    {
        _Ty *_Tmp = _Myptr;
        _Myptr = 0;
        return (_Tmp);
    }

    void reset(_Ty *_Ptr = 0)   //将当前保存的指针所指向的地方释放并存储新的指针
    {
        if (_Ptr != _Myptr)
            delete _Myptr;
        _Myptr = _Ptr;
    }

private:
    _Ty *_Myptr;    //普通指针
};

一般可使用的接口为：

auto_ptr::get();    //返回原始指针
auto_ptr::release();    //将当前保存的普通指针删除并返回这个指针的值
auto_ptr::reset();  //将当前保存的指针所指向的地方释放并存储新的指针

C++11后引入了一些新的指针（来源是boost库），这些新的指针功能如下：

std	boost	功能说明
unique_ptr	scoped_ptr	独占指针对象，并保证指针所指对象生命周期与其一致
shared_ptr	shared_ptr	可共享指针对象，可以赋值给shared_ptr或weak_ptr。指针所指对象在所有的相关联的shared_ptr生命周期结束时结束，是强引用。
weak_ptr	weak_ptr	它不能决定所指对象的生命周期，引用所指对象时，需要lock()成shared_ptr才能使用。

偷个懒，马一篇智能指针不错的博客
C++11中智能指针的原理、使用、实现

C++ 智能指针

1 autp_ptr(C++11之前)

猜你喜欢