本文轉自博友程式媛想事兒。

原文位址：

http://blog.csdn.net/lanxuezaipiao/article/details/41603883

導讀

最近在補看《C++ Primer Plus》第六版，這的确是本好書，其中關于智能指針的章節解析的非常清晰，一解我以前的多處困惑。C++面試過程中，很多面試官都喜歡問智能指針相關的問題，比如你知道哪些智能指針？shared_ptr的設計原理是什麼？如果讓你自己設計一個智能指針，你如何完成？等等……。而且在看開源的C++項目時，也能随處看到智能指針的影子。這說明智能指針不僅是面試官愛問的題材，更是非常有實用價值。

下面是我在看智能指針時所做的筆記，希望能夠解決你對智能指針的一些困擾。

正文

1. 智能指針背後的設計思想

我們先來看一個簡單的例子：

void remodel(std::string & str)
{
    std::string * ps = new std::string(str);
    ...
    if (weird_thing())
        throw exception();
    str = *ps; 
    delete ps;
    return;
}

當出現異常時（weird_thing()傳回true），delete将不被執行，是以将導緻記憶體洩露。

如何避免這種問題？有人會說，這還不簡單，直接在throw exception();之前加上delete ps;不就行了。是的，你本應如此，問題是很多人都會忘記在适當的地方加上delete語句（連上述代碼中最後的那句delete語句也會有很多人忘記吧），如果你要對一個龐大的工程進行review，看是否有這種潛在的記憶體洩露問題，那就是一場災難！

這時我們會想：當remodel這樣的函數終止（不管是正常終止，還是由于出現了異常而終止），本地變量都将自動從棧記憶體中删除—是以指針ps占據的記憶體将被釋放，如果ps指向的記憶體也被自動釋放，那該有多好啊。

我們知道析構函數有這個功能。如果ps有一個析構函數，該析構函數将在ps過期時自動釋放它指向的記憶體。但ps的問題在于，它隻是一個正常指針，不是有析構凼數的類對象指針。如果它指向的是對象，則可以在對象過期時，讓它的析構函數删除指向的記憶體。

這正是 auto_ptr、unique_ptr和shared_ptr這幾個智能指針背後的設計思想。我簡單的總結下就是：将基本類型指針封裝為類對象指針（這個類肯定是個模闆，以适應不同基本類型的需求），并在析構函數裡編寫delete語句删除指針指向的記憶體空間。

是以，要轉換remodel()函數，應按下面3個步驟進行：

包含頭義件memory（智能指針所在的頭檔案）；

将指向string的指針替換為指向string的智能指針對象；

删除delete語句。

下面是使用auto_ptr修改該函數的結果：

# include <memory>
void remodel (std::string & str)
{
    std::auto_ptr<std::string> ps (new std::string(str))；
    ...
    if (weird_thing ())
        throw exception()； 
    str = *ps； 
    // delete ps； NO LONGER NEEDED
    return;
}

2. C++智能指針簡單介紹

STL一共給我們提供了四種智能指針：auto_ptr、unique_ptr、shared_ptr和weak_ptr（本文章暫不讨論）。

模闆auto_ptr是C++98提供的解決方案，C+11已将将其摒棄，并提供了另外兩種解決方案。然而，雖然auto_ptr被摒棄，但它已使用了好多年：同時，如果您的編譯器不支援其他兩種解決力案，auto_ptr将是唯一的選擇。

使用注意點

所有的智能指針類都有一個explicit構造函數，以指針作為參數。比如auto_ptr的類模闆原型為：

templet<class T>
class auto_ptr {
    explicit auto_ptr(X* p = ) ; 
    ...
};

是以不能自動将指針轉換為智能指針對象，必須顯式調用：

shared_ptr<double> pd; 
double *p_reg = new double;
pd = p_reg;                               // not allowed (implicit conversion)
pd = shared_ptr<double>(p_reg);           // allowed (explicit conversion)
shared_ptr<double> pshared = p_reg;       // not allowed (implicit conversion)
shared_ptr<double> pshared(p_reg);        // allowed (explicit conversion)

對全部三種智能指針都應避免的一點：

string vacation("I wandered lonely as a cloud.");
shared_ptr<string> pvac(&vacation);   // No

pvac過期時，程式将把delete運算符用于非堆記憶體，這是錯誤的。

使用舉例

#include <iostream>
#include <string>
#include <memory>

class report
{
private:
    std::string str;
public:
 report(const std::string s) : str(s) {
  std::cout << "Object created.\n";
 }
 ~report() {
  std::cout << "Object deleted.\n";
 }
 void comment() const {
  std::cout << str << "\n";
 }
};

int main() {
 {
  std::auto_ptr<report> ps(new report("using auto ptr"));
  ps->comment();
 }

 {
  std::shared_ptr<report> ps(new report("using shared ptr"));
  ps->comment();
 }

 {
  std::unique_ptr<report> ps(new report("using unique ptr"));
  ps->comment();
 }
 return ;
}

3. 為什麼摒棄auto_ptr？

先來看下面的指派語句:

auto_ptr< string> ps (new string ("I reigned lonely as a cloud.”）;
auto_ptr<string> vocation; 
vocaticn = ps;

上述指派語句将完成什麼工作呢？如果ps和vocation是正常指針，則兩個指針将指向同一個string對象。這是不能接受的，因為程式将試圖删除同一個對象兩次——一次是ps過期時，另一次是vocation過期時。要避免這種問題，方法有多種：

定義陚值運算符，使之執行深複制。這樣兩個指針将指向不同的對象，其中的一個對象是另一個對象的副本，缺點是浪費空間，是以智能指針都未采用此方案。
建立所有權（ownership）概念。對于特定的對象，隻能有一個智能指針可擁有，這樣隻有擁有對象的智能指針的構造函數會删除該對象。然後讓指派操作轉讓所有權。這就是用于auto_ptr和uniqiie_ptr 的政策，但unique_ptr的政策更嚴格。
建立智能更高的指針，跟蹤引用特定對象的智能指針數。這稱為引用計數。例如，指派時，計數将加1，而指針過期時，計數将減1,。當減為0時才調用delete。這是shared_ptr采用的政策。

當然，同樣的政策也适用于複制構造函數。

每種方法都有其用途，但為何說要摒棄auto_ptr呢？

下面舉個例子來說明。

#include <iostream>
#include <string>
#include <memory>
using namespace std;

int main() {
  auto_ptr<string> films[] =
 {
  auto_ptr<string> (new string("Fowl Balls")),
  auto_ptr<string> (new string("Duck Walks")),
  auto_ptr<string> (new string("Chicken Runs")),
  auto_ptr<string> (new string("Turkey Errors")),
  auto_ptr<string> (new string("Goose Eggs"))
 };
 auto_ptr<string> pwin;
 pwin = films[]; // films[2] loses ownership. 将所有權從films[2]轉讓給pwin，此時films[2]不再引用該字元串進而變成空指針

 cout << "The nominees for best avian baseballl film are\n";
 for(int i = ; i < ; ++i)
  cout << *films[i] << endl;
 cout << "The winner is " << *pwin << endl;
 cin.get();

 return ;
}

運作下發現程式崩潰了，原因在上面注釋已經說的很清楚，films[2]已經是空指針了，下面輸出通路空指針當然會崩潰了。但這裡如果把auto_ptr換成shared_ptr或unique_ptr後，程式就不會崩潰，原因如下：

使用shared_ptr時運作正常，因為shared_ptr采用引用計數，pwin和films[2]都指向同一塊記憶體，在釋放空間時因為事先要判斷引用計數值的大小是以不會出現多次删除一個對象的錯誤。

使用unique_ptr時編譯出錯，與auto_ptr一樣，unique_ptr也采用所有權模型，但在使用unique_ptr時，程式不會等到運作階段崩潰，而在編譯器因下述代碼行出現錯誤：

unique_ptr<string> pwin;
pwin = films[]; // films[2] loses ownership.

指導你發現潛在的記憶體錯誤。

這就是為何要摒棄auto_ptr的原因，一句話總結就是：避免潛在的記憶體崩潰問題。

4. unique_ptr為何優于auto_ptr？

可能大家認為前面的例子已經說明了unique_ptr為何優于auto_ptr，也就是安全問題，下面再叙述的清晰一點。

請看下面的語句:

auto_ptr<string> p1(new string ("auto") ； //#1
auto_ptr<string> p2;                       //#2
p2 = p1;

在語句#3中，p2接管string對象的所有權後，p1的所有權将被剝奪。前面說過，這是好事，可防止p1和p2的析構函數試圖刪同—個對象；

但如果程式随後試圖使用p1，這将是件壞事，因為p1不再指向有效的資料。

下面來看使用unique_ptr的情況：

unique_ptr<string> p3 (new string ("auto");   //#4
unique_ptr<string> p4；                       //#5
p4 = p3;    //#6

編譯器認為語句#6非法，避免了p3不再指向有效資料的問題。是以，unique_ptr比auto_ptr更安全。

但unique_ptr還有更聰明的地方。

有時候，會将一個智能指針賦給另一個并不會留下危險的懸挂指針。假設有如下函數定義：

unique_ptr<string> demo(const char * s)
{
    unique_ptr<string> temp (new string (s))； 
    return temp；
}

并假設編寫了如下代碼：

unique_ptr<string> ps;
ps = demo('Uniquely special")；

demo()傳回一個臨時unique_ptr，然後ps接管了原本歸傳回的unique_ptr所有的對象，而傳回時臨時的 unique_ptr 被銷毀，也就是說沒有機會使用 unique_ptr 來通路無效的資料，換句話來說，這種指派是不會出現任何問題的，即沒有理由禁止這種指派。實際上，編譯器确實允許這種指派，這正是unique_ptr更聰明的地方。

總之，黨程式試圖将一個 unique_ptr 指派給另一個時，如果源 unique_ptr 是個臨時右值，編譯器允許這麼做；如果源 unique_ptr 将存在一段時間，編譯器将禁止這麼做，比如：

unique_ptr<string> pu1(new string ("hello world"));
unique_ptr<string> pu2;
pu2 = pu1;                                      // #1 not allowed
unique_ptr<string> pu3;
pu3 = unique_ptr<string>(new string ("You"));   // #2 allowed

其中#1留下懸挂的unique_ptr(pu1)，這可能導緻危害。而#2不會留下懸挂的unique_ptr，因為它調用 unique_ptr 的構造函數，該構造函數建立的臨時對象在其所有權讓給 pu3 後就會被銷毀。這種随情況而已的行為表明，unique_ptr 優于允許兩種指派的auto_ptr 。

當然，您可能确實想執行類似于#1的操作，僅當以非智能的方式使用摒棄的智能指針時（如解除引用時），這種指派才不安全。要安全的重用這種指針，可給它賦新值。C++有一個标準庫函數std::move()，讓你能夠将一個unique_ptr賦給另一個。下面是一個使用前述demo()函數的例子，該函數傳回一個unique_ptr對象：

使用move後，原來的指針仍轉讓所有權變成空指針，可以對其重新指派。

unique_ptr<string> ps1, ps2;
ps1 = demo("hello");
ps2 = move(ps1);
ps1 = demo("alexia");
cout << *ps2 << *ps1 << endl;

5. 如何選擇智能指針？

在掌握了這幾種智能指針後，應使用哪種智能指針呢？

（1）如果程式要使用多個指向同一個對象的指針，應選擇shared_ptr。這樣的情況包括：

- 有一個指針數組，并使用一些輔助指針來标示特定的元素，如最大的元素和最小的元素；

- 兩個對象包含都指向第三個對象的指針；

- STL容器包含指針。

很多STL算法都支援複制和指派操作，這些操作可用于shared_ptr，但不能用于unique_ptr（編譯器發出warning）和auto_ptr（行為不确定）。如果你的編譯器沒有提供shared_ptr，可使用Boost庫提供的shared_ptr。

（2）如果程式不需要多個指向同一個對象的指針，則可使用unique_ptr。如果函數使用new配置設定記憶體，并返還指向該記憶體的指針，将其傳回類型聲明為unique_ptr是不錯的選擇。這樣，所有權轉讓給接受傳回值的unique_ptr，而該智能指針将負責調用delete。可将unique_ptr存儲到STL容器在那個，隻要不調用将一個unique_ptr複制或賦給另一個算法（如sort()）。例如，可在程式中使用類似于下面的代碼段。

unique_ptr<int> make_int(int n)
{
    return unique_ptr<int>(new int(n));
}
void show(unique_ptr<int> &p1)
{
    cout << *a << ' ';
}
int main()
{
    ...
    vector<unique_ptr<int> > vp(size);
    for(int i = ; i < vp.size(); i++)
        vp[i] = make_int(rand() % );              // copy temporary unique_ptr
    vp.push_back(make_int(rand() % ));     // ok because arg is temporary
    for_each(vp.begin(), vp.end(), show);           // use for_each()
    ...
}

其中push_back調用沒有問題，因為它傳回一個臨時unique_ptr，該unique_ptr被賦給vp中的一個unique_ptr。另外，如果按值而不是按引用給show()傳遞對象，for_each()将非法，因為這将導緻使用一個來自vp的非臨時unique_ptr初始化pi，而這是不允許的。前面說過，編譯器将發現錯誤使用unique_ptr的企圖。

在unique_ptr為右值時，可将其賦給shared_ptr，這與将一個unique_ptr賦給一個需要滿足的條件相同。與前面一樣，在下面的代碼中，make_int()的傳回類型為unique_ptr：

unique_ptr<int> pup(make_int(rand() % ));   // ok
shared_ptr<int> spp(pup);                       // not allowed, pup as lvalue
shared_ptr<int> spr(make_int(rand() % ));   // ok

模闆shared_ptr包含一個顯式構造函數，可用于将右值unique_ptr轉換為shared_ptr。shared_ptr将接管原來歸unique_ptr所有的對象。

在滿足unique_ptr要求的條件時，也可使用auto_ptr，但unique_ptr是更好的選擇。如果你的編譯器沒有unique_ptr，可考慮使用Boost庫提供的scoped_ptr，它與unique_ptr類似。

C++智能指針簡單剖析導讀目錄正文

導讀

目錄

正文

1. 智能指針背後的設計思想

2. C++智能指針簡單介紹

3. 為什麼摒棄auto_ptr？

4. unique_ptr為何優于auto_ptr？

5. 如何選擇智能指針？

繼續閱讀

c++ 比對相鄰元素相等的元素（adjacent_find）

DateTimePicker 控件的格式設定

swmm與lisflood-fp源碼如何一起編譯 CMake指令

Windows下VS開發環境環境安裝工程項目設定關于Debug和Release的提示

一文看懂字元串的加減乘除

C++ 第十五周報告1--《冒泡法排序》

C++數組引用C++數組引用

C++實作簡單順序表

[C++學習曆程]基礎部分 C++中的函數學習

C經典書籍筆記——C陷阱與缺陷②(文法陷阱之優先級)一、錯誤案列二、優先級規律

使用遞減運算符在循環中按遞減順序列印10到0之間的整數

指針，常量和類型别名

VS C++常見問題集錦1.在Vs中編C出現這兩個錯誤是什麼原因？錯誤1：error LNK2005: _main 已經在 *** 中定義

線性表之順序表的實作

C++判斷素數、求最大公約數代碼判斷一個數是否為素數求兩個數的最大公約數

SequoiaDB巨杉資料庫C++驅動概述