C++的auto_ptr所做的事情，就是动态分配对象以及当对象不再需要时自动执行清理。
使用std::auto_ptr，要#include <memory>。 [1]  
自动指针
auto_ptr
编辑
在C++中， auto_ptr是一个类，它用来实现对动态分配对象的自动释放。
它的源代码：
template < class  T>
class  auto_ptr
{
private :
     T*ap;
public :
     //constructor & destructor-----------------------------------(1)
     explicit  auto_ptr(T*ptr=0) throw ():ap(ptr)
     {
     }
 
     ~auto_ptr() throw ()
     {
         delete  ap;
     }
     //Copy & assignment--------------------------------------------(2)
     auto_ptr(auto_ptr& rhs) throw ():ap(rhs.release())
     {
     }
     template < class  Y>
     auto_ptr(auto_ptr<Y>&rhs) throw ():ap(rhs.release())
     {
     }
     auto_ptr& operator=(auto_ptr&rhs) throw ()
     {
         reset(rhs.release());
         return * this ;
     }
     template < class  Y>
     auto_ptr& operator=(auto_ptr<Y>&rhs) throw ()
     {
         reset(rhs.release());
         return * this ;
     }
     //Dereference----------------------------------------------------(3)
     T& operator*() const  throw ()
     {
         return *ap;
     }
     T* operator->() const  throw ()
     {
         returnap;
     }
     //Helper functions------------------------------------------------(4)
     //value access
     T* get() const  throw ()
     {
         returnap;
     }
     //release owner ship
     T* release() throw ()
     {
         T*tmp(ap);
         ap=0;
         return  tmp;
     }
     //reset value
     void  reset(T*ptr=0) throw ()
     {
         if (ap!=ptr)
         {
             deleteap;
             ap=ptr;
         }
     }
     //Special conversions-----------------------------------------------(5)
     template < class  Y>
     struct  auto_ptr_ref
     {
         Y*yp;
         auto_ptr_ref(Y*rhs):yp(rhs){}
     };
     auto_ptr(auto_ptr_ref<T>rhs) throw ():ap(rhs.yp)
     {
     }
     
     auto_ptr& operator=(auto_ptr_ref<T>rhs) throw ()
     {
         reset(rhs.yp);
         return * this ;
     }
     
     template < class  Y>
     operator auto_ptr_ref<Y>() throw ()
     {
         returnauto_ptr_ref<Y>(release());
     }
     
     template < class  Y>
     operator auto_ptr<Y>() throw ()
     {
         returnauto_ptr<Y>(release());
     }
};
1
2
1
2
3
1
2
1
2
3
4
1
2
3
4
1
2
3
4
5
6
7
8
1
2
1
1
2
3
4
5
6
1
2
3
4
5
6
7
8
1
(0));
auto_ptr<int>(new int(0))是一个临时对象，同时是一个右值，一般的 拷贝构造函数当然能拷贝右值，因为其参数类别必须为一个const reference,　但是我们知道，auto_ptr的拷贝函数其参数类型为reference，所以，为了使这行代码能通过，我们引入auto_ptr_ref来实现从右值向 左值的转换。其过程为：
1) ap1要通过拷贝 auto_ptr<int>(new int(0))来构造自己
2) auto_ptr<int>(new int(0))作为右值与现有的两个拷贝构造函数参数类型都无法匹配，也无法转换成该种参数类型
3) 发现辅助的 拷贝构造函数auto_ptr(auto_ptr_ref<T> rhs) throw()
4) 试图将auto_ptr<int>(new int(0))转换成auto_ptr_ref<T>
5) 发现 类型转换函数operator auto_ptr_ref<Y>() throw()，转换成功。
6)调用auto_ptr(auto_ptr_ref<T>rhs)throw()完成auto_ptr_ref向auto_ptr的构造。
从而通过一个间接类成功的实现了拷贝构造右值（临时对象）
同时，这个辅助方法不会使const auto_ptr被拷贝，　原因是在第5步，　此类型转换函数为non-const的，我们知道，const对象是无法调用non-const成员的，　所以转换失败。当然，　这里有一个问题要注意，　假设你把这些辅助转换的代码注释掉，该行代码还是可能成功编译，这是为什么呢？debug一下，　我们可以发现只调用了一次 构造函数，而 拷贝构造函数并没有被调用，原因在于 编译器将 代码优化掉了。这种类型优化叫做returned value optimization，它可以有效防止一些无意义的临时对象的构造。当然，前提是你的编译器要支持returned value optimization。