C++11 智能指針

2019-11-08 18:42:06

字體：大中小

來源：轉載

供稿：網友

轉載自：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_ptrunique_ptrweak_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也釋放資源。