auto_ptr

auto_ptr指针介绍(智能指针)

　　auto_ptr指针介绍

　　auto_ptr是这样一种指针：它是“它所指向的对象”的拥有者。这种拥有具有唯一性，即一个对象只能有一个拥有者，严禁一物二主。当auto_ptr指针被摧毁时，它所指向的对象也将被隐式销毁，即使程序中有异常发生，auto_ptr所指向的对象也将被销毁。

　　1、设计动机：

　　在函数中通常要获得一些资源，执行完动作后，然后释放所获得的资源，当程序员忘记释放所申请的到的资源，或者由于异常发生而没有正常释放资源时，这就将产生一系列的内存泄漏问题。

　　因此，你可能将函数写成如下形式：

　　void fun()

　　{

　　try

　　{

　　T *ptr = new T;

　　......

　　}catch(...)

　　{

　　delete ptr;

　　throw;

　　}

　　delete ptr;

　　}

　　这样使程序变得太过复杂。使用auto_ptr可以使上述程序简化为：

　　void fun()

　　{

　　auto_ptr<T> ptr(new T);

　　......

　　}

　　不再需要delete，也不再需要catch了。与上面的程序相比，这个非常简单。

　　auto_ptr是一个模板类，适合于任何类型，其接口行为与普通指针相似，opeator *用来提取其所指向对象的值。operator->用来指向对象中的成员。但是，他没有定义任何的算术运算（包括++）。

　　由于auto_ptr定义中“用一般指针构造一个auto_ptr”的构造函数被声明为explicit（拒绝隐式变换），所以一下的方式是错误的：

　　auto_ptr<int> ptr = new int(0); // 错

　　必须这样：

　　auto_ptr<int> ptr(new int(0)); //正确

　　2、auto_ptr拥有权的转移

　　由于auto_ptr指针唯一性，即一个对象只能有一个auto_ptr指针所指向它。因此，当auto_ptr以传值方式被作为参数传递给某函数时，这时对象的原来拥有者（实参）就放弃了对象的拥有权，把它转移到被调用函数中的参数（形参）上，如果函数不再将拥有权传递出去，由于形参的作用域仅仅为函数内部，当函数退出时，它所指向的对象将被销毁。当函数返回一个auto_ptr时，其拥有权又被转移到了调用端。

　　因此，应该尽量不要在参数中使用auto_ptr指针，我们也不要通过引用传递auto_ptr。

　　当然一个方法是我们可以通过使用常量引用来实现auto_ptr的传递，我们也可以声明一个const auto_ptr指针，这样将使auto_ptr不能转移它的拥有权。

　　例如：

　　void print(auto_ptr<int> ptr);

　　const auto_ptr<int> p(new int(0));

　　*p = 10;

　　print(p); //编译时发生错误

　　当auto_ptr被使用最为一个类成员时，由于其可能发生拥有权转移的问题，所以你必须亲自写复制构造函数和复制运算操作符。

　　3、auto_ptr的错误运用：

　　1)、auto_ptr之间不能共享一个对象。一个auto_ptr不能指向另一个auto_ptr所指向的的对象。否则，当第一个指针删除该对象时，另一个指针马上就指向了一个已经被销毁的对象，那么，如果在使用该指针，就会引发某些错误。

　　2)、并不存在针对array而设计的auto_ptr。auto_ptr不可以指向一个array，因为auto_ptr是通过delete而不是delete[]来释放其所拥有的资源的。

　　3)、auto_ptr绝非是一个通用的智能指针。并非任何适用智能型指针地方都可以适用auto_ptr指针。

　　4)、auto_ptr不满足STL容器对其元素的要求。因为在拷贝和赋值动作以后，原本的auto_ptr和新产生的auto_ptr并不相等，在拷贝和赋值之后，原本的auto_ptr会交出拥有权，而不是拷贝给新的auto_ptr。因此，决不要将auto_ptr作为标准容器的元素。

　　以下附auto_ptr部分源代码：

　　template <class T>

　　class auto_ptr

　　{

　　private:

　　T * ptr;

　　public:

　　typedef T element_type;

　　explicit auto_ptr(T* __p = 0) throw() : ptr(__p) {}

　　auto_ptr(auto_ptr& __a) throw() : ptr(__a.release()) {}

　　template <class _Tp1>

　　auto_ptr(auto_ptr<_Tp1>& __a) throw(): ptr(__a.release()) {}

　　auto_ptr& operator=(auto_ptr& __a) throw()

　　{

　　if (&__a != this)

　　{

　　delete ptr;

　　ptr = __a.release();

　　}

　　return *this;

　　}

　　template <class _Tp1>

　　auto_ptr& operator=(auto_ptr<_Tp1>& __a)throw()

　　{

　　if (__a.get() != this->get())

　　{

　　delete ptr;

　　ptr = __a.release();

　　}

　　return *this;

　　}

　　~auto_ptr() throw() { delete ptr; }

　　T& operator*() const throw() { return *ptr; }

　　T* operator->() const throw() { return ptr; }

　　T* get() const throw() { return ptr; }

　　T* release() throw()

　　{

　　T* __tmp = ptr;

　　ptr = 0;

　　return __tmp;

　　}

　　void reset(T* __p = 0) throw()

　　{

　　delete ptr;

　　ptr = __p;

　　}

　　}

 

使用：

使用std::auto_ptr需要的头文件: #include <memory>

// 示例 1(b): 安全代码, 使用了auto_ptr
　void f()
　{
　　 auto_ptr<T> pt( new T );

    .....
　} // 酷: 当pt出了作用域时析构函数被调用，从而对象被自动删除

　　现在代码不会泄漏T类型的对象，不管这个函数是正常退出还是抛出了异常，因为pt的析构函数总是会在出栈时被调用。清理会自动进行。
　　最后，使用一个auto_ptr就像使用一个内建的指针一样容易，而且如果想要“撤销”资源，重新采用手动的所有权，我们只要调用release().

　　 // 示例 2: 使用一个 auto_ptr
　　 void g()
　　 {
　　 T* pt1 = new T;  // 现在，我们有了一个分配好的对象
　　  auto_ptr<T> auto_pt2( pt1 ); // 将所有权传给了一个auto_ptr对象,auto_pt2 指向了 pt1

　　 // 使用auto_ptr就像我们以前使用简单指针一样
　　 auto_pt2 = 12; // 就像 "*pt1 = 12;"
　　 auto_pt2->SomeFunc(); // 就像 "pt1->SomeFunc();"

　　 // 用get()来获得指针的值
　　 assert( pt1 == auto_pt2.get() );  // 二者一样
　　 // 用release()来撤销所有权， auto_pt2 把保存的指针地址给了pt3, 而自己指向了NUll。
　　 T* pt3 = auto_pt2.release();  //
　　 // 自己删除这个对象，因为现在没有任何auto_ptr拥有这个对象
　　 delete pt3;
　　 } // pt2不再拥有任何指针，所以不要试图删除它...ok，不要重复删除

　　最后，我们可以使用auto_ptr的reset()函数来重置auto_ptr使之拥有另一个对象。如果这个auto_ptr已经拥有了一个对象，那么，它会先删除已经拥有的对象，因此调用reset()就如同销毁这个auto_ptr，然后新建一个并拥有一个新对象：
　　 // 示例 3: 使用reset()
　　 //
　　 void h()
　　 {
　　 auto_ptr<T> pt( new T(1) );
　　 pt.reset( new T(2) );  //即pt会首先delete pt目前指向的地址（new T(1)得到的地址)，

                            //然后再指向new T(2)分配的地址
　　 } // 最后，pt出了作用域，
　　 // 第二个T也被自动删除了

1 构造函数与析构函数　　
auto_ptr在构造时获取对某个对象的所有权(ownership),在析构时释放该对象。我们可以这样使用auto_ptr来提高代码安全性：　　
    int* p = new int(0); 　　
    auto_ptr<int> ap(p); 　　
从此我们不必关心应该何时释放p，　也不用担心发生异常会有内存泄漏。　　
这里我们有几点要注意：　　
1) 因为auto_ptr析构的时候肯定会删除他所拥有的那个对象，所有我们就要注意了，一个萝卜一个坑，两个auto_ptr不能同时拥有同一个对象。像这样：　　
    int* p = new int(0); 　　
    auto_ptr<int> ap1(p); 　　
    auto_ptr<int> ap2(p); 　　
因为ap1与ap2都认为指针p是归它管的，在析构时都试图删除p,　两次删除同一个对象的行为在C++标准中是未定义的。所以我们必须防止这样使用auto_ptr. 　　
2) 考虑下面这种用法：　　
    int* pa = new int[10]; 　　
    auto_ptr<int> ap(pa); 　　
因为auto_ptr的析构函数中删除指针用的是delete,而不是delete [],所以我们不应该用auto_ptr来管理一个数组指针。　　
3) 构造函数的explicit关键词有效阻止从一个“裸”指针隐式转换成auto_ptr类型。　　
4) 因为C++保证删除一个空指针是安全的，　所以我们没有必要把析构函数写成：　　
~auto_ptr() throw() 　　
{ 　　
    if(ap)
    delete ap; 　　
} 　　
2 拷贝构造与赋值 　　
与引用计数型智能指针不同的，auto_ptr要求其对“裸”指针的完全占有性。也就是说一个”裸“指针不能同时被两个以上的auto_ptr所拥有。那么，在拷贝构造或赋值操作时，我们必须作特殊的处理来保证这个特性。auto_ptr的做法是“所有权转移”，即拷贝或赋值的源对象将失去对“裸”指针的所有权，所以，与一般拷贝构造函数，赋值函数不同，auto_ptr的拷贝构造函数，赋值函数的参数为引用而不是常引用(const reference). 当然，一个auto_ptr也不能同时拥有两个以上的“裸”指针，所以，拷贝或赋值的目标对象将先释放其原来所拥有的对象。这里的注意点是：　　
1) 因为一个auto_ptr被拷贝或被赋值后，　其已经失去对原对象的所有权，这个时候，对这个auto_ptr的提领(dereference)操作是不安全的。如下: 　　
    int* p = new int(0);
 　　auto_ptr<int> ap1(p);
 　　auto_ptr<int> ap2 = ap1;
 　　cout<<*ap1; //错误，此时ap1只剩一个null指针在手了 　　
这种情况较为隐蔽的情形出现在将auto_ptr作为函数参数按值传递，因为在函数调用过程中，在函数的作用域中会产生一个局部对象来接收传入的auto_ptr(拷贝构造)，这样，传入的实参auto_ptr就失去了其对原对象的所有权，而该对象会在函数退出时被局部auto_ptr删除。如下：
 　　void f(auto_ptr<int> ap)
    {
        cout<<*ap;
    } 　　
    auto_ptr<int> ap1(new int(0)); 　　
    f(ap1);
 　cout<<*ap1; //错误，经过f(ap1)函数调用，ap1已经不再拥有任何对象了。　　
因为这种情况太隐蔽，太容易出错了，　所以auto_ptr作为函数参数按值传递是一定要避免的。或许大家会想到用auto_ptr的指针或引用作为函数参数或许可以，但是仔细想想，我们并不知道在函数中对传入的auto_ptr做了什么，如果当中某些操作使其失去了对对象的所有权，　那么这还是可能会导致致命的执行期错误。也许，用const reference的形式来传递auto_ptr会是一个不错的选择。　　

2)我们可以看到拷贝构造函数与赋值函数都提供了一个成员模板在不覆盖“正统”版本的情况下实现auto_ptr的隐式转换。如我们有以下两个类　　
    class base{};
 　 class derived: public base{};
 　　那么下列代码就可以通过，实现从auto_ptr<derived>到auto_ptr<base>的隐式转换，因为derived*可以转换成base*类型
 　　auto_ptr<base> apbase = auto_ptr<derived>(new derived);
 　　
3) 因为auto_ptr不具有值语义(value semantic), 所以auto_ptr不能被用在stl标准容器中。
 　　所谓值语义，是指符合以下条件的类型(假设有类A)：
 　　A a1;
 　　A a2(a1);
 　　A a3;
 　　a3 = a1;
 　　那么
 　　a2 == a1, a3 == a1
 　　很明显，auto_ptr不符合上述条件，而我们知道stl标准容器要用到大量的拷贝赋值操作，并且假设其操作的类型必须符合以上条件。　　

3 提领操作(dereference) 　　
提领操作有两个操作，一个是返回其所拥有的对象的引用，　另一个是则实现了通过auto_ptr调用其所拥有的对象的成员。如：
 　　struct A 　　{ 　　void f(); 　　}
 　　auto_ptr<A> apa(new A);
 　　(*apa).f();
 　　apa->f();
 　　当然，我们首先要确保这个智能指针确实拥有某个对象，否则，这个操作的行为即对空指针的提领是未定义的。　　

4 辅助函数 　　
1) get用来显式的返回auto_ptr所拥有的对象指针。我们可以发现，标准库提供的auto_ptr既不提供从“裸”指针到auto_ptr的隐式转换 (构造函数为explicit),也不提供从auto_ptr到“裸”指针的隐式转换，从使用上来讲可能不那么的灵活，　考虑到其所带来的安全性还是值得的。
2) release,用来转移所有权　　
3) reset，用来接收所有权，如果接收所有权的auto_ptr如果已经拥有某对象，　必须先释放该对象。　　

5 特殊转换 　　
这里提供一个辅助类auto_ptr_ref来做特殊的转换，按照标准的解释，　这个类及下面 4个函数的作用是：使我们得以拷贝和赋值non-const auto_ptrs，　却不能拷贝和赋值const auto_ptrs. 我无法非常准确的理解这两句话的意义，但根据我们观察与试验，应该可以这样去理解：没有这些代码，我们本来就可以拷贝和赋值non-const的 auto_ptr和禁止拷贝和赋值const的auto_ptr的功能，　只是无法拷贝和赋值临时的auto_ptr(右值)，　而这些辅助代码提供某些转换，使我们可以拷贝和赋值临时的auto_ptr，但并没有使const的auto_ptr也能被拷贝和赋值。如下：
 　　auto_ptr<int> ap1 = auto_ptr<int>(new int(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()，　转换成功，从而拷贝成功。　　
从而通过一个间接类成功的实现了拷贝构造右值（临时对象）时，这个辅助方法不会使const auto_ptr被拷贝，　原因是在第5步，　此类型转换函数为non-const的，我们知道，const对象是无法调用non-const成员的，　所以转换失败。当然，　这里有一个问题要注意，　假设你把这些辅助转换的代码注释掉，该行代码还是可能成功编译，这是为什么呢？debug一下，　我们可以发现只调用了一次构造函数，而拷贝构造函数并没有被调用，原因在于编译器将代码优化掉了。这种类型优化叫做returned value optimization，它可以有效防止一些无意义的临时对象的构造。当然，前提是你的编译器要支持returned value optimization。