auto_ptr源码解析

C++ STL的auto_ptr实现（位于memory头文件中）如下：

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

//auto_ptr的proxy类，因为auto_ptr本身的copy构造和赋值函数不支持const引用参数（右值的类型），特定义此类为const引用代理

//在auto_ptr中添加参数类型为auto_ptr_ref<_Ty>的copy构造和赋值函数，同时添加proxy类-〉auto_ptr的隐式类型转换函数和构造函数

//对于右值copy，编译器的动作为：rvalue auto_ptr --> auto_ptr_ref --> auto_ptr的转换。

template<class _Ty>
struct auto_ptr_ref
{ // proxy reference for auto_ptr copying
explicit auto_ptr_ref(_Ty *_Right)
: _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 _Ty element_type;

//constructor使用explicit防止编译器隐式类型转换，（default）构造函数保证内部指针指向有效地址或0

// _THROW0(): #define _THROW0() throw () 异常规格说明保证此函数不抛出任何异常，否则系统就抛出unexpected ex然后terminate()

explicit auto_ptr(_Ty *_Ptr = 0) _THROW0()
: _Myptr(_Ptr)
{ // construct from object pointer
}

//copy constructor 1.是指针传递不是deep copy和指针copy，即指针所指对象的所有权传递到新构造的auto_ptr<T>对象，原auto_ptr<T>release指针对象的所有权，所以参数不能为const（要修改），所以要小心使用调用copy constructor的地方：函数参数传值（可能造成对象所有权传递到临时对象中）和返回对象！！！

//2.实现不能为指针copy：因为auto_ptr对象析构会自动delete raw 指针，指针copy会导致double delete

//3.实现不能为deep copy，因为参数是指针，你不知道指针具体所指的类型（多态）无法调用正确的new函数，也许你说你可以使用RTTI，但是你能保证指针所指的类型有virtual table（[0]一般用于存放type_info）吗,另外还有C++从c那继承来的强类型。。。 另外还有效率问题。。。

auto_ptr(auto_ptr<_Ty>& _Right) _THROW0()
: _Myptr(_Right.release())
{ // construct by assuming pointer from _Right auto_ptr
}

//以auto_ptr_ref代理const引用参数的copy构造函数

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
}

//隐式类型转换函数模板，若_Other*可转换为_Ty*则此函数模板实例化后可编译通过，auto_ptr<_Ty>可转换为auto_ptr<_Other>

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

//proxy类-〉auto_ptr的隐式类型转换函数

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);
}

// 同隐式类型转换函数模版的以autoptr<_Other>作为参数值的赋值和copy constructor
template<class _Other>
auto_ptr<_Ty>& 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
}

//适用于copy constructor的条款同样适用于copy assignment，另外注意两者的区别：后者的对象已构造好，所以

//1. 应该检查是不是“自己=自己” 2. 为支持连=返回（*this） 3.在重新赋值之前释放原有的资源 4.如果赋值有可能失败，要保证原有值不能被破坏

//这里仍然是巧妙的指针传递，检测1在reset中

auto_ptr<_Ty>& operator=(auto_ptr<_Ty>& _Right) _THROW0()
{ // assign compatible _Right (assume pointer)
reset(_Right.release());
return (*this);
}

//以auto_ptr_ref代理const引用参数的copy赋值函数

auto_ptr<_Ty>& 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，如果外面有其他pointer也指向相同的对象，那小心不要double delete，同时也不要写出两个auto_ptr指向同一个堆对象，如果有必要那用reference couting吧

~auto_ptr()
{ // destroy the object

//析构函数为什么不直接使用delete（因为在c++标准中delete空指针是安全的）？
if (_Myptr != 0)
delete _Myptr;
}

//dereference函数 1.为什么返回引用而不是T对象？

//因为指针和引用都支持多态，而返回对象会调用static type的copy constructor，有可能出现slice（如派生类->基类）

//2.记得检测空指针，dereference空指针会很恐怖：（

//3.加const为保证const auto_ptr<T>对象的调用，不能修改指针，但可以修改指针所指的值

_Ty& operator*() const _THROW0()
{ // return designated value

#if _HAS_ITERATOR_DEBUGGING
if (_Myptr == 0)
_DEBUG_ERROR("auto_ptr not dereferencable");
#endif /* _HAS_ITERATOR_DEBUGGING */

__analysis_assume(_Myptr);

return (*get());
}

//operator->类似于operator*(),但是注意operator->返回的结果要使用member-selection operator(->)，所以返回dumb pointer或另一个auto_ptr

_Ty *operator->() const _THROW0()
{ // return pointer to class object

#if _HAS_ITERATOR_DEBUGGING
if (_Myptr == 0)
_DEBUG_ERROR("auto_ptr not dereferencable");
#endif /* _HAS_ITERATOR_DEBUGGING */

return (get());
}

//get获取dumb pointer

_Ty *get() const _THROW0()
{ // return wrapped pointer
return (_Myptr);
}

//release释放并返回dumb pointer，则返回的pointer不在此auto_ptr内释放，外部delete或其他auto_ptr自动释放

_Ty *release() _THROW0()
{ // return wrapped pointer and give up ownership
_Ty *_Tmp = _Myptr;
_Myptr = 0;
return (_Tmp);
}

//reset先释放原有的再和新的pointer关联

void reset(_Ty* _Ptr = 0)
{ // destroy designated object and store new pointer
if (_Ptr != _Myptr && _Myptr != 0)
delete _Myptr;
_Myptr = _Ptr;
}

private:

//dumb pointer

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

• auto_ptr是什么？为什么要用它？
  smart pointer，防止memory leak和便于程序员编程时的内存管理
• auto_ptr的典型应用case？
  取代局部指针变量
  类的指针成员变量
  （待续。。）
• 用auto_ptr需要引用的头文件：

#include<memory>
std::auto_ptr<T> ptr(T*)

• auto_ptr和dump pointer的区别？

auto_ptr析构时自动释放所指对象，但是它是对象不是T*，所以：
auto_ptr<T> ptr;
1.不能使用if( ptr ) / if( ptr == 0 ) / if( !ptr )判断是否空指针
2.不能传给int fun(T*);作为参数，但是可以将auto_ptr<T>转为T*,或这样调用 fun( &*ptr )。

• 为什么防止编译器隐式转换auto_ptr为dump pointer？

auto_ptr<T> ptr;
隐式类型转换还是少用为好，它会隐藏很多bug，比如本错误的语句delete ptr也是合法的，另外complier的一次隐式类型转换只能调用一次用户自定义的类型转换函数

摘自：http://hi.baidu.com/kellyfu_ying/blog/category/c%2Cc%2B%2B