【C++深入浅出】智能指针之auto_ptr学习

起： 

C++98标准加入auto_ptr，即智能指针，C++11加入shared_ptr和weak_ptr两种智能指针，先从auto_ptr的定义学习一下auto_ptr的用法。

template<class _Ty>

class auto_ptr

{ // wrap an object pointer to ensure destruction

public:

//定义_Myt类型，作用域局限于类中，便于书写和理解

typedef auto_ptr<_Ty> _Myt;

typedef _Ty element_type;

//显式调用构造函数，对类型进行检查并构造一个_Ty类型的指针

//未定义默认构造函数 

explicit auto_ptr(_Ty *_Ptr = 0) _THROW0()

: _Myptr(_Ptr)

{ // construct from object pointer

}

//定义了复制构造函数，稍微有些奇特的复制构造函数，构造了this以后，_Right就会变成一个_Myt类型的NULL指针，这点须谨记，具体参见release的定义。

//上面即所有权转移，同一个指针在多个auto_ptr对象之间只会存在一份所有权，可以避免析构的重复delete错误。

auto_ptr(_Myt& _Right) _THROW0()

: _Myptr(_Right.release())

{ // construct by assuming pointer from _Right auto_ptr

}

//通过auto_ptr_ref结构体来构造智能指针，所有权转移

auto_ptr(auto_ptr_ref<_Ty> _Right) _THROW0()

{ // 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()

{ // convert to compatible auto_ptr

return (auto_ptr<_Other>(*this));

}

template<class _Other>

operator auto_ptr_ref<_Other>() _THROW0()

{ // 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);

}

//赋值操作符=的重载函数之一：独占新指针的所有权并delete当前拥有的指针

template<class _Other>

_Myt& operator=(auto_ptr<_Other>& _Right) _THROW0()

{ // assign compatible _Right (assume pointer)

reset(_Right.release());

return (*this);

}

template<class _Other>

auto_ptr(auto_ptr<_Other>& _Right) _THROW0()

: _Myptr(_Right.release())

{ // construct by assuming pointer from _Right

}

//赋值操作符=的重载之一：独占新指针的所有权并delete当前拥有的指针

_Myt& operator=(_Myt& _Right) _THROW0()

{ // assign compatible _Right (assume pointer)

reset(_Right.release());

return (*this);

}

//赋值操作符=的重载之一：独占新指针的所有权并delete当前拥有的指针

_Myt& operator=(auto_ptr_ref<_Ty> _Right) _THROW0()

{ // assign compatible _Right._Ref (assume pointer)

_Ty *_Ptr = _Right._Ref;

_Right._Ref = 0; // release old

reset(_Ptr); // set new

return (*this);

}

//析构删除当前指向的资源，用的delete而非delete []，所以只能用来删除单个抽象数据对象，不能删除数组，需要关注，指向的对象应该是用new构造出来的，而不是new []构造的。

~auto_ptr() _NOEXCEPT

{ // destroy the object

delete _Myptr;

}

//重载*操作符，返回指向的对象

_Ty& operator*() const _THROW0()

{ // return designated value

 #if _ITERATOR_DEBUG_LEVEL == 2

if (_Myptr == 0)

_DEBUG_ERROR("auto_ptr not dereferencable");

 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

return (*get());

}

//重载操作符->，内部调用get()方法

_Ty *operator->() const _THROW0()

{ // 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()

{ // return wrapped pointer

return (_Myptr);

}

//将this指针指向NULL，并返回指向资源的指针

_Ty *release() _THROW0()

{ // return wrapped pointer and give up ownership

_Ty *_Tmp = _Myptr;

_Myptr = 0;

return (_Tmp);

}

//delete已拥有的指针并获取新的指针所有权，reset使用时候要注意这一点

void reset(_Ty *_Ptr = 0)

{ // destroy designated object and store new pointer

if (_Ptr != _Myptr)

delete _Myptr;

_Myptr = _Ptr;

}

private:

_Ty *_Myptr; // the wrapped object pointer

};

学习小结：

1. 每一个auto_ptr都是一个ADT对象，auto_ptr应当被定义成局部或临时变量，以便自动析构拥有的指针。

2. auto_ptr中很重要的一个理念就是所有权转移，所有权转移就是auto_ptr会接管赋给他们的指针的所有权，以后这个指针有且仅有一个auto_ptr拥有。复制构造和赋值操作都会接管指针的所有权。

3. 从整个设计理念看，get()和release()提供了某些灵活性的同时破坏了概念的一致性，使用不当会导致某些错误，所有权不再由唯一的auto_ptr具有，要少用这两个接口。

4. auto_ptr适用于管理new出来的指针，不适用new[]出来的指针，也不要用auto_ptr指向静态分配对象的指针。

5. auto_ptr不满足STL容器的基本要求，因为auto_ptr的复制操作是所有权的转移，而不是所有权的拷贝，不要试图用容器来容纳auto_ptr，也不适用sort等内部会对元素进行拷贝的函数。

6. auto_ptr提供的接口列表：显式构造函数、复制构造函数的各个重载版本、赋值操作符的各个重载版本、操作符*、操作符->、release()、get()、reset()。

 后记：

学习boost，认为boost中的一种与auto_ptr极其类似的智能指针scoped_ptr的设计是不错的，auto_ptr的所有权可以转移，同一时间只有一个auto_ptr可以管理指针，但还是具有一定的危险性，而scoped_ptr把拷贝构造函数和赋值函数全都私有化，保证了指针的绝对安全，从概念上保持了完整性，大多数时候是一种更好的选择。