auto_ptr源碼 const auto_ptr保證擁有權(quán)不能轉(zhuǎn)移的實現(xiàn)原理？
-----------------------------------------------------------------------------------------------

在《C++標(biāo)準(zhǔn)程序庫》p55，提到了auto_ptr使用了一個技巧，能夠copy和復(fù)制non-const auto_ptr,但不可以copy和復(fù)制const atuo_ptr。
//auto_ptr的源碼：
template
struct auto_ptr_ref
{
    _Tp1* _M_ptr;
    
      explicit
      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
};

template
class auto_ptr
{
    private:
        _Tp* _M_ptr;
     
    public:
       typedef _Tp element_type;
     
       explicit
       auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }

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

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

       auto_ptr&
       operator=(auto_ptr& __a) throw()
       {
reset(__a.release());
return *this;
       }

       template
       auto_ptr&
       operator=(auto_ptr<_Tp1>& __a) throw()
       {
  reset(__a.release());
  return *this;
       }

       ~auto_ptr() { delete _M_ptr; }
     
       element_type&
       operator*() const throw()
       {
  _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
  return *_M_ptr;
       }
     
       element_type*
       operator->() const throw()
       {
 _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
 return _M_ptr;
       }
     
       element_type*
       get() const throw() { return _M_ptr; }
     
       element_type*
       release() throw()
       {
  element_type* __tmp = _M_ptr;
  _M_ptr = 0;
  return __tmp;
       }
     
       void
       reset(element_type* __p = 0) throw()
       {
 if (__p != _M_ptr)
 {
    delete _M_ptr;
    _M_ptr = __p;
 }
       }
     
       auto_ptr(auto_ptr_ref __ref) throw()
       : _M_ptr(__ref._M_ptr) { }
     
       auto_ptr&
       operator=(auto_ptr_ref __ref) throw()
       {
 if (__ref._M_ptr != this->get())
 {
    delete _M_ptr;
    _M_ptr = __ref._M_ptr;
 }
 return *this;
       }
     
      template
      operator auto_ptr_ref<_Tp1>() throw()
      { return auto_ptr_ref<_Tp1>(this->release()); }

      template
      operator auto_ptr<_Tp1>() throw()
      { return auto_ptr<_Tp1>(this->release()); }
};//VC7中的

---------------------------------------------------------------------------------------------------------------
// TEMPLATE CLASS auto_ptr
template
    class auto_ptr;

template
    struct auto_ptr_ref
        {    // proxy reference for auto_ptr copying
    auto_ptr_ref(auto_ptr<_Ty>& _Right)
        : _Ref(_Right)
        {    // construct from compatible auto_ptr
        }

    auto_ptr<_Ty>& _Ref;    // reference to constructor argument
    };

template
    class auto_ptr
        {    // wrap an object pointer to ensure destruction
public:
    typedef _Ty element_type;

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

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

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

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

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

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

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

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

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

    ~auto_ptr()
        {    // destroy the object
        delete _Myptr;
        }

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

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

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

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

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

private:
    _Ty *_Myptr;    // the wrapped object pointer
    };
----------------------------------------------------------------------------------------------------------
C++中的auto_ptr (修改版本) stl 文件中的 std::auto_ptr 在C++中的故事特別多, 在它的演變過程中至少出現(xiàn)了3個版本.
http://www.josuttis.com/libbook/auto_ptr.html 這個連接里面有它完整的故事.
VC6中STL帶的auto_ptr( 帶owner字段)的版本應(yīng)該就是文中說的Version 2.

最新的Version里面包含了一個auto_ptr_ref, 這個是當(dāng)將auto_ptr作為函數(shù)返回值和函數(shù)參數(shù)時需要引入的
一個"額外間接層".

下面是它的一些說明:

auto_ptr的拷貝構(gòu)造函數(shù)和一般我們常見的不同, 它的參數(shù)rhs并不是const reference, 而是refence,

auto_ptr( /*const */ auto_ptr& rhs)
{
  ...
}

假設(shè)我們需要將一個auto_ptr作為某個函數(shù)的返回值, 例如
auto_ptr source()
{
  return auto_ptr(new int(3));
}

那么我們?nèi)绾卧赾aller中得到返回的結(jié)果呢?
理所當(dāng)然的語法是:
auto_ptr p( source() );     (拷貝構(gòu)造函數(shù))
或者
auto_ptr p = source();      (拷貝構(gòu)造函數(shù))
或者
auto_ptr p = ...;           (operator=)
p = source();

但是如果沒有auto_ptr_ref的存在, 上面這些行實際上應(yīng)該是一個編譯錯誤(VC6不報錯), 原因是:

C++中有左值/右值之分, 函數(shù)如果返回值, 那么是r-value. 右值作為reference函數(shù)參數(shù)時, 只能是const reference.
因此source函數(shù)返回的auto_ptr作為rhs實參調(diào)用auto_ptr的拷貝構(gòu)造函數(shù)時, 只能是const refernce, 但是
這個函數(shù)的簽名需要rhs為reference, 因此無法編譯.
舉個最簡單的例子:
有函數(shù):
int foo() { return 0; }
void bar(int & i) { }
調(diào)用
int& i  = foo() ;       //錯誤
const int& i = foo();   //OK
bar(foo())              //錯誤

同理, 拷貝構(gòu)造函數(shù)不過是一個特殊的"函數(shù)"而已, 我們上面的source函數(shù)返回的auto_ptr對象也只能作為一個
const auto_ptr&, 但是這個拷貝構(gòu)造函數(shù)需要的參數(shù)原型是auto_ptr&, 而不是const auto_ptr& .
因此auto_ptr引入了一個'額外的間接層' auto_ptr_ref, 來完成一個從r-value到l-value之間的過渡.

基本的思路是;
提供另外一個構(gòu)造函數(shù), 接受一個以值傳遞的auto_ptr_ref:
auto_ptr( auto_ptr_ref ref)
{
      ....
}

然后在auto_ptr類中, 提供一個自動轉(zhuǎn)型的函數(shù)
operator auto_ptr_ref ()
{
    .....
}

這樣, source返回一個auto_ptr, 編譯器嘗試調(diào)用拷貝構(gòu)造函數(shù), 發(fā)現(xiàn)參數(shù)不必配(期望const), 然后發(fā)現(xiàn)了一個自動轉(zhuǎn)型的
operator auto_ptr_ref()函數(shù), 而后又發(fā)現(xiàn)通過調(diào)用該自動轉(zhuǎn)型得到一個auto_ptr_ref對象后, 可以調(diào)用caller的
auto_ptr的以auto_ptr_ref為參數(shù)的非explicit的構(gòu)造函數(shù), 完成了一個auto_ptr到另外一個auto_ptr之間的復(fù)制過程.

注意一點: operator auto_ptr_ref () 不是const成員函數(shù).
C++語法規(guī)則中對于臨時變量的r-value有個詭秘的地方就是:
如果你需要將r-value保存在一個reference中, 或者作為某個refence的函數(shù)參數(shù), 那么必須為const reference,
但是你也可以在一個完整的表達(dá)式中直接使用這個臨時變量, 這種情況下該臨時變量實際上并不是作為const reference對待,
因為你可以調(diào)用它的非const成員函數(shù). 例如:

class Integer
{
public:

  void zero() { i = 0; }

private:
  int i;
};

class Integer
{
public:

  void zero() { i = 0; }

private:
  int i;
};

Integer().zero();       //創(chuàng)建一個Integer的臨時變量, 然后調(diào)用非const成員函數(shù).

這樣, auto_ptr p( source() );

實際上發(fā)生的事情就是:
 auto_ptr p( source().operator auto_ptr_ref());

通過source()函數(shù)得到一個臨時的auto_ptr對象, 然后調(diào)用其中的自動轉(zhuǎn)換函數(shù)得到一個auto_ptr_ref,
即使該轉(zhuǎn)型函數(shù)是非const成員函數(shù)仍然可行.

然后調(diào)用 p 對象的以auto_ptr_ref為參數(shù)的構(gòu)造函數(shù)進(jìn)行復(fù)制.
然后, source()函數(shù)創(chuàng)建的臨時對象在整個表達(dá)式結(jié)束后被析構(gòu), 當(dāng)然這個時候這個臨時對象內(nèi)部的指針已經(jīng)被reset(0)了,
因為該指針的擁有權(quán)已經(jīng)被p接管了. (否則會重復(fù)刪除)

std::auto_ptr在很多情況下是很便利的, 例如一個函數(shù)內(nèi)部需要通過new分配一個結(jié)構(gòu), 那么誰來釋放是一個問題,
一種原則是誰分配, 誰釋放, 但是對于這種情況顯然不合適.
利用auto_ptr就簡單得多了: 誰擁有誰釋放, 誰都不要那么就編譯器自動釋放它. 例如

有個函數(shù):
auto_ptr create_sth()
{
  auto_ptr p(new sth);
  return p;
}

調(diào)用1:
auto_ptr p = create_sth();
...
p退出作用域, 自動釋放.

調(diào)用2:
create_sth();
沒有人接受這個返回的對象, 那么編譯器自動會調(diào)用auto_ptr的析構(gòu)函數(shù)釋放之.

sink也是一個作用:
例如我已經(jīng)擁有一個auto_ptr對象的指針, 那么我可以定義一個sink函數(shù), 原型如下:
void sink(auto_ptr p)
{
}

正如sink名字暗示的一樣, sink函數(shù)起到一個吸收作用, 將某個外部的auto_ptr對象吸收過來,類似于宇宙中的"黑洞".
例如:
  auto_ptr p(new sth);
  sink(p);
  //這里, p指向null了, p所指的sth對象已經(jīng)被sink函數(shù)"吸收"了.

當(dāng)然為了防止這種情況在你不注意的情況下發(fā)生, 你可以
const auto_ptr p(new sth);
sink(p); //編譯錯誤
auto_ptr p2 = p;        //編譯錯誤

這樣, 一個const auto_ptr的對象一旦構(gòu)造完成, 永遠(yuǎn)不會失去對該對象的擁有權(quán). "一旦擁有, 從不失去".

當(dāng)然auto_ptr最重要的作用, 也是它的原始目的是為了提供異常安全.

auto_ptr
動態(tài)內(nèi)存使用最多的是在C++應(yīng)用程序的代碼中。有過編程經(jīng)驗的程序員雖然都知道new操作符的使用一定要與delete匹配，在某些場合仍然可能有內(nèi)存溢出。當(dāng)異常被擲出時，程序的正常控制流程被改變，因此導(dǎo)致潛在的內(nèi)存溢出。例如， 
void g() //可能擲出
  {
    if (some_condition == false)
      throw X();
  }
  void func()
  {
    string * pstr = new string;
    g(); //如果 g 擲出一個異常，內(nèi)存溢出
    delete pstr; //如果 g 擲出一個異常，則此行為不能達(dá)到的代碼行。
  }
  int main()
  {
    try
    {
      func();
    }
    catch(...)
    {}
  }
 
    當(dāng) g 擲出一個異常，異常處理機制展開堆棧：g()退出，同時控制被轉(zhuǎn)移到 main() 的 catch(...)代碼塊。這時，無論怎樣，func()中的delete語句都不會被執(zhí)行，由此導(dǎo)致pstr的內(nèi)存溢出。要是使用局部自動串變量，而不是使用動態(tài)分配-內(nèi)存溢出就不會出現(xiàn)了：

string str; //局部自動對象
g(); //沒有內(nèi)存溢出 
    許多數(shù)據(jù)重要的結(jié)構(gòu)以及應(yīng)用，象鏈表，STL容器，串，數(shù)據(jù)庫系統(tǒng)以及交互式應(yīng)用必須使用動態(tài)內(nèi)存分配，因此仍然冒著萬一發(fā)生異常導(dǎo)致內(nèi)存溢出的風(fēng)險。C++標(biāo)準(zhǔn)化委員會意識到了這個漏洞并在標(biāo)準(zhǔn)庫中添加了一個特殊的類模板，它就是std::auto_ptr，其目的是促使動態(tài)內(nèi)存和異常之前進(jìn)行平滑的交互。Auto_ptr保證當(dāng)異常擲出時分配的對象（即：new操作符分配的對象）能被自動銷毀，內(nèi)存能被自動釋放。下面我們就來討論使用動態(tài)內(nèi)存時，如何正確和有效地使用auto_ptr來避免資源溢出。這個技術(shù)適用于文件，線程，鎖定以及與此類似的資源。

    Auto_ptr的定義可以在中找到。與標(biāo)準(zhǔn)庫中其它的成員一樣，它被聲明在命名空間std::中。當(dāng)你實例化auto_ptr對象時，對它進(jìn)行初始化的方法是用一個指針指向動態(tài)分配的對象，下面是實例化和初始化auto_ptr對象的例子： 
include
  #include
  using namespace std;
  void func()
  {
    auto_ptr pstr (new string); /* 創(chuàng)建并初始化auto_ptr */
  }
 
    auto_ptr后面的尖括弧里指定auto_ptr指針的類型，在這個例子中是string。然后auto_ptr句柄的名字，在這個例子中是pstr。最后是用動態(tài)分配的對象指針初始化這個實例。注意你只能使用auto_ptr構(gòu)造器的拷貝，也就是說，下面的代碼是非法的： 
auto_ptr pstr  = new string; //編譯出錯
 
    Auto_ptr是一個模板，因此它是完全通用的。它可以指向任何類型的對象，包括基本的數(shù)據(jù)類型： 
auto_ptr pi  (new int);
 
    一旦你實例化一個auto_ptr，并用動態(tài)分配的對象地址對它進(jìn)行了初始化，就可以將它當(dāng)作普通的對象指針使用，例如： 
*pstr = "hello world"; //賦值
  pstr->size(); //調(diào)用成員函數(shù)
 
    之所以能這樣做是因為auto_ptr重載了操作符&,*和->。不要被語法誤導(dǎo)，記住pstr是一個對象，不是一個指針。

    auto_ptr是如何解決前面提到的內(nèi)存溢出問題呢？auto_ptr的析構(gòu)函數(shù)自動摧毀它綁定的動態(tài)分配對象。換句話說，當(dāng)pstr的析構(gòu)函數(shù)執(zhí)行時，它刪除構(gòu)造pstr期間創(chuàng)建的串指針。你絕不能刪除auto_ptr，因為它是一個本地對象，它的析構(gòu)函數(shù)是被自動調(diào)用的。讓我們看一下函數(shù)func()的修訂版本,這次使用了auto_ptr： 
void func()
  {
    auto_ptr  pstr (new string);
    g();  //如果g()擲出異常，pstr 被自動摧毀
  }
 
    C++保證在堆棧展開過程中，自動存儲類型的對象被自動摧毀。因此，如果g()擲出異常，pstr的析構(gòu)函數(shù)將會在控制被轉(zhuǎn)移到catch(...)塊之前執(zhí)行。因為pstr的析構(gòu)函數(shù)刪除其綁定的串指針，所以不會有內(nèi)存溢出發(fā)生。這樣我們在使用動態(tài)分配對象時，利用auto_ptr就實現(xiàn)了自動和安全的本地對象。

如何避免使用auto_ptr的缺陷

    auto_ptr并不是完美無缺的，它的確很方便，但也有缺陷，在使用時要注意避免。首先，不要將auto_ptr對象作為STL容器的元素。C++標(biāo)準(zhǔn)明確禁止這樣做，否則可能會碰到不可預(yù)見的結(jié)果（在另文中討論）。

    auto_ptr的另一個缺陷是將數(shù)組作為auto_ptr的參數(shù)： 
auto_ptr  pstr (new char[12] ); //數(shù)組；為定義
 
    記住不管什么時候使用數(shù)組的new操作時，必須要用delete[]來摧毀數(shù)組。因為auto_ptr的析構(gòu)函數(shù)只對非數(shù)組類型起作用。所以數(shù)組是不能被正確摧毀的話，程序的行為是不明確的。總之，auto_ptr控制一個由new分配的單對象指針，僅此而已。 
--------------------------------------------------------------------------------------------------
Misusing auto_ptrs

auto_ptrs satisfy a certain need; namely, to avoid resource leaks when exception handling is used. Unfortunately, the exact behavior of auto_ptrs changed in the past and no other kind of smart pointers are provided in the C++ standard library, so people tend to misuse auto_ptrs. Here are some hints to help you use them correctly: