auto_ptr智能指针

转自：    http://blog.csdn.net/u013696062/article/details/39477571
    C++中的auto_ptr（俗称智能指针）所做的事情，使用起来就像普通指针，但当其动态分配内存时，不再需要考虑清理问题。当它的生存期结束时，系统会自动清理它指向的内存。
        其实auto_ptr是一个模版类(注意实质上还是一个类)。主要解决内存泄漏问题。
        原理：其实就是RAII，在构造的时候获取资源，在析构的时候释放资源，并进行相关指针操作的重载，使用起来就像普通的指针（!!!其实实质上还是一个类）。
0. 先看看如何使用：

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

注意头文件是#include
注意是auto_ptr而不是auto_ptr。观察源代码发现类auto_ptr的私有成员是T* ap;所以这里是而不是。

最重要的就是理解源码：

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 ap=auto_ptr(new int(1));
//auto_ptr ap;
//ap=auto_ptr (new int(1));
如果想使得这两个式子成立，必须要有auto_ptr_ref。
首先：
//auto_ptr ap=auto_ptr(new int(1));
因为auto_ptr(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 ap;
//ap=auto_ptr (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技术。