C++11 智能指針

轉載自：http://www.jianshu.com/p/e4919f1c3a28

原作者：Babu_Abdulsalam 本文翻譯自CodeProject，轉載請註明出處。

引入

Ooops. 儘管有另外一篇文章說C++11裏的智能指針了。近來，我聽到許多人談論C++新標準，就是所謂的C++0x/C++11。我研究了一下C++11的一些語言特性，發現確實它確實有一些巨大的改變。我將重點關注C++11的智能指針部分。

背景

普通指針（normal/raw/naked pointers）的問題？

讓我們一個接一個的討論。

如果不恰當處理指針就會帶來許多問題，所以人們總是避免使用它。這也是許多新手程序員不喜歡指針的原因。指針總是會扯上很多問題，例如指針所指向對象的生命週期，掛起引用（dangling references）以及內存泄露。

如果一塊內存被多個指針引用，但其中的一個指針釋放且其餘的指針並不知道，這樣的情況下，就發生了掛起引用。而內存泄露，就如你知道的一樣，當從堆中申請了內存後不釋放回去，這時就會發生內存泄露。有人說，我寫了清晰並且帶有錯誤驗證的代碼，爲什麼我還要使用智能指針呢？一個程序員也問我：“嗨，下面是我的代碼，我從堆（heap）中申請了一塊內存，使用完後，我又正確的把它歸還給了堆，那麼使用智能指針的必要在哪裏？”

void Foo( )
{ 
    int* iPtr = new int[5];  
    //manipulate the memory block . . .  
    delete[ ] iPtr;
 }

理想狀況下，上面這段代碼確實能夠工作的很好，內存也能夠恰當的釋放回去。但是仔細思考一下實際的工作環境以及代碼執行條件。在內存分配和釋放的間隙，程序指令確實能做許多糟糕的事情，比如訪問無效的內存地址，除以0，或者有另外一個程序員在你的程序中修改了一個bug，他根據一個條件增加了一個過早的返回語句。

在以上所有情況下，你的程序都走不到內存釋放的那部分。前兩種情況下，程序拋出了異常，而第三種情況，內存還沒釋放，程序就過早的return了。所以程序運行時，內存就已經泄露了。

解決以上所有問題的方法就是使用智能指針[如果它們足夠智能的話]。

什麼是智能指針？

智能指針是一個RAII（Resource Acquisition is initialization）類模型，用來動態的分配內存。它提供所有普通指針提供的接口，卻很少發生異常。在構造中，它分配內存，當離開作用域時，它會自動釋放已分配的內存。這樣的話，程序員就從手動管理動態內存的繁雜任務中解放出來了。

C++98提供了第一種智能指針：auto_ptr

auto_ptr

讓我們來見識一下auto_ptr如何解決上述問題的吧。

class Test
{
    public: 
    Test(int a = 0 ) : m_a(a) { }
    ~Test( )
    { 
       cout << "Calling destructor" << endl; 
    }
    public: int m_a;
};
void main( )
{ 
    std::auto_ptr<Test> p( new Test(5) ); 
    cout << p->m_a << endl;
}

上述代碼會智能地釋放與指針綁定的內存。作用的過程是這樣的：我們申請了一塊內存來放Test對象，並且把他綁定到auto_ptr p上。所以當p離開作用域時，它所指向的內存塊也會被自動釋放。

//***************************************************************
class Test
{
public:
 Test(int a = 0 ) : m_a(a)
 {
 }
 ~Test( )
 {
  cout<<"Calling destructor"<<endl;
 }
public:
 int m_a;
};
//***************************************************************
void Fun( )
{
 int a = 0, b= 5, c;
 if( a ==0 )
 {
  throw "Invalid divisor";
 }
 c = b/a;
 return;
}
//***************************************************************
void main( )
{
 try
 {
  std::auto_ptr<Test> p( new Test(5) ); 
  Fun( );
  cout<<p->m_a<<endl;
 }
 catch(...)
 {
  cout<<"Something has gone wrong"<<endl;
 }
}

上面的例子中，儘管異常被拋出，但是指針仍然正確地被釋放了。這是因爲當異常拋出時，棧鬆綁（stack unwinding）,當try 塊中的所有對象destroy後，p 離開了該作用域，所以它綁定的內存也就釋放了。

Issue1：

目前爲止，auto_ptr還是足夠智能的，但是它還是有一些根本性的破綻的。當把一個auto_ptr賦給另外一個auto_ptr時，它的所有權(ownship)也轉移了。當我在函數間傳遞auto_ptr時，這就是一個問題。話說，我在Foo()中有一個auto_ptr，然後在Foo()中我把指針傳遞給了Fun()函數，當Fun()函數執行完畢時，指針的所有權不會再返還給Foo。

//***************************************************************
class Test
{
public:
 Test(int a = 0 ) : m_a(a)
 {
 }
 ~Test( )
 {
  cout<<"Calling destructor"<<endl;
 }
public:
 int m_a;
};


//***************************************************************
void Fun(auto_ptr<Test> p1 )
{
 cout<<p1->m_a<<endl;
}
//***************************************************************
void main( )
{
 std::auto_ptr<Test> p( new Test(5) ); 
 Fun(p);
 cout<<p->m_a<<endl;
}

由於auto_ptr的野指針行爲，上面的代碼導致程序崩潰。在這期間發生了這些細節，p擁有一塊內存，當Fun調用時， p把關聯的內存塊的所有權傳給了auto_ptr p1, p1是p的copy（注：這裏從Fun函數的定義式看出，函數參數時值傳遞，所以把p的值拷進了函數中），這時p1就擁有了之前p擁有的內存塊。目前爲止，一切安好。現在Fun函數執行完了，p1離開了作用域，所以p1關聯的內存塊也就釋放了。那麼p呢？p什麼都沒了，這就是crash的原因了，下一行代碼還試圖訪問p，好像p還擁有什麼資源似的。

Issue2：

還有另外一個缺點。auto_ptr不能指向一組對象，就是說它不能和操作符new[]一起使用。

//***************************************************************
void main( )
{
 std::auto_ptr<Test> p(new Test[5]);
}

上面的代碼將產生一個運行時錯誤。因爲當auto_ptr離開作用域時，delete被默認用來釋放關聯的內存空間。當auto_ptr只指向一個對象時，這當然是沒問題的，但是在上面的代碼裏，我們在堆裏創建了一組對象，應該使用delete[]來釋放，而不是delete.

Issue3:

auto_ptr不能和標準容器（vector,list,map....)一起使用。

因爲auto_ptr容易產生錯誤，所以它也將被廢棄了。C++11提供了一組新的智能指針，每一個都各有用武之地。

shared_ptr
unique_ptr
weak_ptr

shared_ptr

好吧，準備享受真正的智能。第一種智能指針是shared_ptr,它有一個叫做共享所有權(sharedownership)的概念。shared_ptr的目標非常簡單：多個指針可以同時指向一個對象，當最後一個shared_ptr離開作用域時，內存纔會自動釋放。

創建：

void main( )
{
 shared_ptr<int> sptr1( new int );
}

使用make_shared宏來加速創建的過程。因爲shared_ptr主動分配內存並且保存引用計數(reference count),make_shared 以一種更有效率的方法來實現創建工作。

void main( )
{
 shared_ptr<int> sptr1 = make_shared<int>(100);
}

上面的代碼創建了一個shared_ptr,指向一塊內存，該內存包含一個整數100，以及引用計數1.如果通過sptr1再創建一個shared_ptr,引用計數就會變成2. 該計數被稱爲強引用(strong reference)，除此之外，shared_ptr還有另外一種引用計數叫做弱引用(weak reference)，後面將介紹。

通過調用use_count()可以得到引用計數，據此你能找到shared_ptr的數量。當debug的時候，可以通過觀察shared_ptr中strong_ref的值得到引用計數。

reference count

析構

shared_ptr默認調用delete釋放關聯的資源。如果用戶採用一個不一樣的析構策略時，他可以自由指定構造這個shared_ptr的策略。下面的例子是一個由於採用默認析構策略導致的問題：

class Test
{
public:
 Test(int a = 0 ) : m_a(a)
 {
 }
 ~Test( )
 {
  cout<<"Calling destructor"<<endl;
 }
public:
         int m_a;
};
void main( )
{
 shared_ptr<Test> sptr1( new Test[5] );
}

在此場景下，shared_ptr指向一組對象，但是當離開作用域時，默認的析構函數調用delete釋放資源。實際上，我們應該調用delete[]來銷燬這個數組。用戶可以通過調用一個函數，例如一個lamda表達式，來指定一個通用的釋放步驟。

void main( )
{
 shared_ptr<Test> sptr1( new Test[5], 
        [ ](Test* p) { delete[ ] p; } );
}

通過指定delete[]來析構，上面的代碼可以完美運行。

接口
就像一個普通指針一樣，shared_ptr也提供解引用操作符*,->。除此之外，它還提供了一些更重要的接口：

get(): 獲取shared_ptr綁定的資源.
reset(): 釋放關聯內存塊的所有權，如果是最後一個指向該資源的shared_ptr,就釋放這塊內存。
unique: 判斷是否是唯一指向當前內存的shared_ptr.
operator bool : 判斷當前的shared_ptr是否指向一個內存塊，可以用if 表達式判斷。

OK，上面是所有關於shared_ptr的描述，但是shared_ptr也有一些問題：
Issues：

void main( )
{
 shared_ptr<int> sptr1( new int );
 shared_ptr<int> sptr2 = sptr1;
 shared_ptr<int> sptr3;
 sptr3 =sptr

Issues:
下表是上面代碼中引用計數變化情況：

引用計數變化

所有的shared_ptrs擁有相同的引用計數，屬於相同的組。上述代碼工作良好，讓我們看另外一組例子。

void main( )
{
 int* p = new int;
 shared_ptr<int> sptr1( p);
 shared_ptr<int> sptr2( p );
}

上述代碼會產生一個錯誤，因爲兩個來自不同組的shared_ptr指向同一個資源。下表給你關於錯誤原因的圖景：

引用計數

避免這個問題，儘量不要從一個裸指針(naked pointer)創建shared_ptr.

class B;
class A
{
public:
 A(  ) : m_sptrB(nullptr) { };
 ~A( )
 {
  cout<<" A is destroyed"<<endl;
 }
 shared_ptr<B> m_sptrB;
};
class B
{
public:
 B(  ) : m_sptrA(nullptr) { };
 ~B( )
 {
  cout<<" B is destroyed"<<endl;
 }
 shared_ptr<A> m_sptrA;
};
//***********************************************************
void main( )
{
 shared_ptr<B> sptrB( new B );
 shared_ptr<A> sptrA( new A );
 sptrB->m_sptrA = sptrA;
 sptrA->m_sptrB = sptrB;
}

上面的代碼產生了一個循環引用.A對B有一個shared_ptr, B對A也有一個shared_ptr ，與sptrA和sptrB關聯的資源都沒有被釋放，參考下表：

sptrA&sptrB

當sptrA和sptrB離開作用域時，它們的引用計數都只減少到1，所以它們指向的資源並沒有釋放！！！！！

如果幾個shared_ptrs指向的內存塊屬於不同組，將產生錯誤。
如果從一個普通指針創建一個shared_ptr還會引發另外一個問題。在上面的代碼中，考慮到只有一個shared_ptr是由p創建的，代碼可以好好工作。萬一程序員在智能指針作用域結束之前刪除了普通指針p。天啦嚕！！！又是一個crash。
循環引用：如果共享智能指針捲入了循環引用，資源都不會正常釋放。

爲了解決循環引用，C++提供了另外一種智能指針：weak_ptr

Weak_Ptr

weak_ptr 擁有共享語義（sharing semantics）和不包含語義（not owning semantics）。這意味着，weak_ptr可以共享shared_ptr持有的資源。所以可以從一個包含資源的shared_ptr創建weak_ptr。

weak_ptr不支持普通指針包含的*，->操作。它並不包含資源所以也不允許程序員操作資源。既然如此，我們如何使用weak_ptr呢？

答案是從weak_ptr中創建shared_ptr然後再使用它。通過增加強引用計數，當使用時可以確保資源不會被銷燬。當引用計數增加時，可以肯定的是從weak_ptr中創建的shared_ptr引用計數至少爲1.否則，當你使用weak_ptr就可能發生如下問題：當shared_ptr離開作用域時，其擁有的資源會釋放，從而導致了混亂。

創建

可以以shared_ptr作爲參數構造weak_ptr.從shared_ptr創建一個weak_ptr增加了共享指針的弱引用計數(weak reference)，意味着shared_ptr與其它的指針共享着它所擁有的資源。但是當shared_ptr離開作用域時，這個計數不作爲是否釋放資源的依據。換句話說，就是除非強引用計數變爲0，纔會釋放掉指針指向的資源，在這裏，弱引用計數(weak reference)不起作用。

void main( )
{
 shared_ptr<Test> sptr( new Test );
 weak_ptr<Test> wptr( sptr );
 weak_ptr<Test> wptr1 = wptr;
}

可以從下圖觀察shared_ptr和weak_ptr的引用計數：

shared_ptr 和weak_ptr變化

將一個weak_ptr賦給另一個weak_ptr會增加弱引用計數(weak reference count)。

所以，當shared_ptr離開作用域時，其內的資源釋放了，這時候指向該shared_ptr的weak_ptr發生了什麼？weak_ptr過期了（expired）。

如何判斷weak_ptr是否指向有效資源，有兩種方法：

調用use-count()去獲取引用計數，該方法只返回強引用計數，並不返回弱引用計數。
調用expired()方法。比調用use_count()方法速度更快。

從weak_ptr調用lock()可以得到shared_ptr或者直接將weak_ptr轉型爲shared_ptr

void main( )
{
 shared_ptr<Test> sptr( new Test );
 weak_ptr<Test> wptr( sptr );
 shared_ptr<Test> sptr2 = wptr.lock( );
}

如之前所述，從weak_ptr中獲取shared_ptr增加強引用計數。

現在讓我們見識一下weak_ptr如何解決循環引用問題：

class B;
class A
{
public:
 A(  ) : m_a(5)  { };
 ~A( )
 {
  cout<<" A is destroyed"<<endl;
 }
 void PrintSpB( );
 weak_ptr<B> m_sptrB;
 int m_a;
};
class B
{
public:
 B(  ) : m_b(10) { };
 ~B( )
 {
  cout<<" B is destroyed"<<endl;
 }
 weak_ptr<A> m_sptrA;
 int m_b;
};

void A::PrintSpB( )
{
 if( !m_sptrB.expired() )
 {  
  cout<< m_sptrB.lock( )->m_b<<endl;
 }
}

void main( )
{
 shared_ptr<B> sptrB( new B );
 shared_ptr<A> sptrA( new A );
 sptrB->m_sptrA = sptrA;
 sptrA->m_sptrB = sptrB;
 sptrA->PrintSpB( ); 
}

引用計數

unique_ptr

unique_ptr也是對auto_ptr的替換。unique_ptr遵循着獨佔語義。在任何時間點，資源只能唯一地被一個unique_ptr佔有。當unique_ptr離開作用域，所包含的資源被釋放。如果資源被其它資源重寫了，之前擁有的資源將被釋放。所以它保證了他所關聯的資源總是能被釋放。

創建
unique_ptr的創建方法和shared_ptr一樣，除非創建一個指向數組類型的unique_ptr。

unique_ptr<int> uptr( new int );

unique_ptr提供了創建數組對象的特殊方法，當指針離開作用域時，調用delete[]代替delete。當創建unique_ptr時，這一組對象被視作模板參數的部分。這樣，程序員就不需要再提供一個指定的析構方法，如下：

unique_ptr<int[ ]> uptr( new int[5] );

當把unique_ptr賦給另外一個對象時，資源的所有權就會被轉移。

記住unique_ptr不提供複製語義（拷貝賦值和拷貝構造都不可以），只支持移動語義(move semantics).

在上面的例子裏，如果upt3和upt5已經擁有了資源，只有當擁有新資源時，之前的資源纔會釋放。

接口

unique_ptr提供的接口和傳統指針差不多，但是不支持指針運算。

unique_ptr提供一個release()的方法，釋放所有權。release和reset的區別在於，release僅僅釋放所有權但不釋放資源，reset也釋放資源。

使用哪一個？

完全取決於你想要如何擁有一個資源，如果需要共享資源使用shared_ptr,如果獨佔使用資源就使用unique_ptr.

除此之外，shared_ptr比unique_ptr更加重，因爲他還需要分配空間做其它的事，比如存儲強引用計數，弱引用計數。而unique_ptr不需要這些，它只需要獨佔着保存資源對象。

C++11 智能指針

引入

背景

auto_ptr

shared_ptr

Weak_Ptr

unique_ptr

使用哪一個？

前端使用 Konva 實現可視化設計器（13）- 折線 - 最優路徑應用【思路篇】

什麼是Qt

cocos2dx3.3+cocostudio1.6屏幕適配筆記

項目管理筆記1

js寫好的時間控件很好用！

MFC&ATL&STL比較

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結