C++中的auto_ptr（俗称智能指针）所做的事情，使用起来就像普通指针，但当其动态分配内存时，不再需要考虑清理问题。当它的生存期结束时，系统会自动清理它指向的内存。

其实auto_ptr是一个模版类(注意实质上还是一个类)。主要解决内存泄漏问题。

原理：其实就是RAII，在构造的时候获取资源，在析构的时候释放资源，并进行相关指针操作的重载，使用起来就像普通的指针（!!!其实实质上还是一个类）。

0. 先看看如何使用：

int * a=new int(5);
auto_ptr<int> ap(a);//获取某个对象的所有权
cout<<(*ap)<<endl;//之后ap就可以像指针一样使用了。

注意头文件是#include<memory>

注意是auto<int>而不是auto<int *>。观察源代码发现类auto_ptr的私有成员是T* ap;所以这里是<int>而不是<int*>。

最重要的就是理解源码：

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()//虽然构造函数中没有new空间，但是这里使用了delete。是因为智能指针是用来获取指针所有权的，而这个指针是指向new出来的空间的。所以析构需要delete
{
delete ap;
}
//Copy--------------------------------------------(2)
//它的copy有两个函数，注意两个copy函数内部实现，源智能指针将失去对指针的所有权。
auto_ptr(auto_ptr &rhs)throw():ap(rhs.release())//同类型的copy，例如：auto_ptr<int> a(p); auto_ptr<int> b(a);-->就是调用了这个copy
{}                                              
template<class Y>
auto_ptr(auto_ptr<Y>& rhs)throw():ap(rhs.release())//模版中的类型不同的copy。例如：auto_ptr<Derived> a(p); auto_ptr<Base> b(a);用于多态中
{}
//assignment
//和copy类似，源智能指针将失去对指针的所有权。
auto_ptr& operator=(auto_ptr& rhs)throw()
{
reset(rhs.release());
return*this;
}
template<class Y>
auto_ptr& operator=(auto_ptr<Y>& rhs)throw()//参照上面的copy，用于多态中。
{
reset(rhs.release());
return*this;
}
//Dereference----------------------------------------------------(3)
//类auto_ptr重载了这两个操作符，使得它用起来像指针一样。
T&operator*()const throw()
{
return*ap;
}
T*operator->()const throw()
{
return ap;
}
//Helperfunctions------------------------------------------------(4)
//类auto_ptr实现了几个公共函数，提供用户使用
//valueaccess
T* get()const throw()//获取该智能指针拥有的指针
{
return ap;
}
//release ownership
T* release()throw()//释放该智能指针拥有的指针
{
T*tmp(ap);
ap=0;
return tmp;
}
//reset value
void reset(T*ptr=0)throw()//给该智能指针重新获取另一个指针的所有权
{
if(ap!=ptr)
{
delete ap;
ap=ptr;
}
}
//Special conversions-----------------------------------------------(5)
//存在的作用是可以使得下列的式子成立。
//auto_ptr<int> ap=auto_ptr<int>(new int(1));
//auto_ptr<int> ap;
//ap=auto_ptr<int> (new int(1));
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()
{
return auto_ptr_ref<Y>(release());
}
template<class Y>
operator auto_ptr<Y>()throw()
{
return auto_ptr<Y>(release());
}
};

注意的方面：

1. 看看构造函数与析构函数

1> auto的构造时获得对某个对象的所有权。

class A
{
public: A(int i):m_a(i)
              {}
        int m_a;
};
int _tmain(int argc, _TCHAR* argv[])
{
       int * a=new int(5);
       A*a=new A(3);
       auto_ptr<int> ap(a);
       //auto_ptr<int> ap=a;   -----(1) error
       auto_ptr<A>apA=auto_ptr<A>(new A(2));
       //auto_ptr<A> apA=new A(2);  ------(2)         error
       //auto_ptr<A> apA=(auto_ptr<A>)a; ------(3)    error
       system("pause");
       return 0;
}

注意:

        前两个错误在于调用了类auto_ptr的copy构造，而很显然没有匹配的copy构造。其实就相当于两个不相干的类的对象进行copy构造，这样显然是不对的。

         3错误在于调用了类的赋值重载，其实就相当于两个不相干的类的对象进行赋值操作，这样显然很荒谬。

2>  因为auto_ptr析构会删除内存。所以不要两个auto_ptr拥有同一对象：

       int * a=new int(5);
       auto_ptr<int> ap1(a);
       auto_ptr<int> ap2(a);

这样是很危险。

3> 因为auto_ptr的析构中删除指针用的是delete，而不是delete[].所以我们不能用auto_ptr来管理一个类对象数组。

2. 拷贝和赋值函数

1> 由源码可知，auto_ptr的拷贝和赋值后，源智能指针将失去对指针的所有权。

       int * p=new int(2);
       auto_ptr<int> a(p);
       auto_ptr<int> b(a);
       //cout<<*a<<endl;    error

2> 由于拷贝和赋值的特殊性，当智能指针作为参数对函数进行传参时，就会出现问题，传参的过程中，系统会自动生成一个临时智能指针，实参对其copy构造，则实参就失去了所有权，而函数结束后，系统会销毁这个临时智能指针，所以连同绑定的指针指向的内存都已经被释放，显然不合理。

所以不要把智能指针当作参数。

3> 有源码中可以看到copy和赋值都有两个函数，而第二个函数就是用于多态的。用子类指针对父类指针进行copy构造和赋值。

4> auto_ptr不能作为STL中的容器对象。因为STL容器中的元素要经常copy和赋值，而auto_ptr会传递所有权，不是值语义的。所以不行。

附：值语义就相当于值传递；对象语义就相当于引用传递。

 3. auto_ptr提供了一些函数可供使用

get();  release();reset();

 4. 说一下特殊转换

//auto_ptr<int> ap=auto_ptr<int>(new int(1));

//auto_ptr<int> ap;

//ap=auto_ptr<int> (new int(1));

如果想使得这两个式子成立，必须要有auto_ptr_ref。

首先：

//auto_ptr<int> ap=auto_ptr<int>(new int(1));

因为auto_ptr<int>(newint(1))是一个临时对象，而临时对象是不能作为copy构造里的引用参数的，所以我们必须重写一个copy构造，使得copy构造的参数不是引用类型。

而我们不能写出这样的copy：auto_ptr(auto_ptr p){};这样显然是不行的，因为传参就会调用copy，则它就会循环调用。所以我们写成：

auto_ptr(auto_ptr_ref<T> rhs)throw():ap(rhs.yp)
{}

之后，我们就要把auto_ptr可以转换成auto_ptr_ref，所以我们写了一个类型转换函数：

template<class Y>
operatorauto_ptr_ref<Y>()throw()
{
returnauto_ptr_ref<Y>(release());
}

这样，我们就可以把那个临时对象转换成auto_ptr_ref，然后再调用我们重写的这个copy构造，我们就实现了这个copy过程。

//auto_ptr<int> ap;

//ap=auto_ptr<int> (new int(1));

而赋值过程和上面的过程是类似的。我们重写赋值函数就可以了。

至此我们用掉用了3个函数。

而auto_ptr_ref里面有4个函数。还有一个：

template<class Y>
operatorauto_ptr<Y>()throw()
{
returnauto_ptr<Y>(release());
}
};

而这个类型转换函数的作用：就是不同模版类型可以相互转换。比如：

template<typename T>
class Base
{
public:
       template<typenameY>
       operator Base<Y>(){
              return Base<Y>();
       }
};
 
int _tmain(int argc, _TCHAR* argv[])
{
       Base<int> a;
       Base<short> b;
       a=b;//OK
       system("pause");
       return 0;
}

使得a=b；可行。但是具体在auto_ptr中，这个函数具体怎么用，还没有遇到这种情况。

心得：

其实这个auto_ptr就是一个类，只是重载了*和->符号，所以它的对象可以像指针一样：*p来返回引用对象。p->来调用对象的成员。需要注意的是类auto_ptr的实现(重点)，比如copy和赋值都跟常理不同。而因为本质上是一个类，所以销毁它是就自动调用了析构函数，使得不会因为异常而内存泄漏。就是RAII技术。

C++中auto_ptr智能指针