• 獲得資源后立刻放進(jìn)管理對(duì)象內(nèi)。以上代碼中 createA 返回的資源被當(dāng)做其管理者 auto_ptr 的初值，也就立刻被放進(jìn)了管理對(duì)象中。
• 管理對(duì)象運(yùn)用析構(gòu)函數(shù)確保資源釋放。不論控制流如何離開區(qū)塊，一旦對(duì)象被銷毀(例如當(dāng)對(duì)象離開作用域)其析構(gòu)函數(shù)自然會(huì)被自動(dòng)調(diào)用，于是資源被釋放。

為什么在 C++11 建議棄用 auto_ptr 嗎?當(dāng)然是 auto_ptr 存在缺陷，所以后續(xù)不被建議使用。

auto_ptr 有一個(gè)不尋常的特質(zhì)：若通過「復(fù)制構(gòu)造函數(shù)或賦值操作符函數(shù)」 copy 它們，它們會(huì)變成 null ，而復(fù)制所得的指針將獲取資源的唯一擁有權(quán)!

見如下例子說明：

意味著 auto_ptr 并非管理動(dòng)態(tài)分配資源的神兵利器。

std::unique_ptr

unique_ptr 也采用所有權(quán)模型，但是在使用時(shí)，是直接禁止通過復(fù)制構(gòu)造函數(shù)或賦值操作符函數(shù) copy 指針對(duì)象，如下例子在編譯時(shí)，會(huì)出錯(cuò)：

shared_ptr 在使用復(fù)制構(gòu)造函數(shù)或賦值操作符函數(shù)后，引用計(jì)數(shù)會(huì)累加并且兩個(gè)指針對(duì)象指向的都是同一個(gè)塊內(nèi)存，這就與 unique_ptr、auto_ptr 不同之處。

由于 shared_ptr 釋放空間時(shí)會(huì)事先要判斷引用計(jì)數(shù)值的大小，因此不會(huì)出現(xiàn)多次刪除一個(gè)對(duì)象的錯(cuò)誤。

小結(jié) - 請(qǐng)記住

• 為防止資源泄漏，請(qǐng)使用 RAII(Resource Acquisition Is Initaliaztion - 資源取得時(shí)機(jī)便是初始化時(shí)機(jī)) 對(duì)象，它們?cè)跇?gòu)造函數(shù)中獲取資源，并在析構(gòu)函數(shù)中是釋放資源
• 兩個(gè)建議使用的 RAII classes 分別是 std::unique_ptr 和 std::shared_ptr。前者不允許 copy 動(dòng)作，后者允許 copy 動(dòng)作。但是不建議用 std::auto_ptr，若選 auto_ptr，復(fù)制動(dòng)作會(huì)使它(被復(fù)制物)指向 null 。

細(xì)節(jié) 02：在資源管理類中小心 copying 行為

假設(shè)，我們使用 C 語音的 API 函數(shù)處理類型為 Mutex 的互斥對(duì)象，共有 lock 和 unlock 兩函數(shù)可用：

void locak(Mutex *pm);  // 鎖定 pm 所指的互斥器 
void unlock(Mutex* pm); // 將互斥器解除鎖定 

為確保絕不會(huì)忘記一個(gè)被鎖住的 Mutex 解鎖，我們可能會(huì)希望創(chuàng)立一個(gè) class 來管理鎖資源。這樣的 class 要遵守 RAII 守則，也就是「資源在構(gòu)造期間獲得，在析構(gòu)釋放期間釋放」：

class Lock 
{ 
public: 
    explicit Lock(Mutex *pm) // 構(gòu)造函數(shù) 
        : pMutex(pm) 
    { 
        lock(pMutex); 
    } 
 
    ~Lock()  // 析構(gòu)函數(shù) 
    { 
        unlock(pMutex); 
    } 
private: 
    Mutex* pMutex; 
}; 

這樣定義的 Lock，用法符合 RAII 方式：

Mutex m;      //定義你需要的互斥鎖 
...  
{                 // 建立一個(gè)局部區(qū)塊作用域 
    Lock m1(&m);  // 鎖定互斥器 
    ... 
}                 // 在離開區(qū)塊作用域，自動(dòng)解除互斥器鎖定 

這很好，但如果 Lock 對(duì)象被復(fù)制，會(huì)發(fā)生什么事情?

Lock m1(&m);  // 鎖定m 
Lock m2(&m1); // 將 m1 復(fù)制到 m2身上，這會(huì)發(fā)生什么？ 

這是我們需要思考和面對(duì)的：「當(dāng)一個(gè) RAII 對(duì)象被復(fù)制，會(huì)發(fā)生什么事情?」大多數(shù)時(shí)候你會(huì)選擇以下兩種可能：

• 禁止復(fù)制。如果 RAII 不允許被復(fù)制，那我們需要將 class 的復(fù)制構(gòu)造函數(shù)和賦值操作符函數(shù)聲明在 private。
• 使用引用計(jì)數(shù)法。有時(shí)候我們希望保有資源，直到它的最后一個(gè)對(duì)象被消耗。這種情況下復(fù)制 RAII 對(duì)象時(shí)，應(yīng)該將資源的「被引用數(shù)」遞增。std::shared_ptr 便是如此。

如果前述的 Lock 打算使用使用引用計(jì)數(shù)法，它可以使用 std::shared_ptr 來管理 pMutex 指針，然后很不幸 std::shared_ptr 的默認(rèn)行為是「當(dāng)引用次數(shù)為 0 時(shí)刪除其所指物」那不是我們想要的行為，因?yàn)橐獙?duì)Mutex釋放動(dòng)作是解鎖而非刪除。

幸運(yùn)的是 std::shared_ptr 允許指定自定義的刪除方式，那是一個(gè)函數(shù)或函數(shù)對(duì)象。如下：

class Lock 
{ 
public: 
    explicit Lock(Mutex *pm)   
        : pMutex(pm, unlock)  // 以某個(gè) Mutex 初始化 shared_ptr， 
                              // 并以 unlock 函數(shù)為刪除器。 
    { 
        lock(pMutex.get());  // get 獲取指針地址 
    } 
 
private: 
    std::shared_ptr<Mutex> pMutex; // 使用 shared_ptr 
}; 

請(qǐng)注意，本例的 Lock class 不再聲明析構(gòu)函數(shù)。因?yàn)榫幾g器會(huì)自動(dòng)創(chuàng)立默認(rèn)的析構(gòu)函數(shù)，來自動(dòng)調(diào)用其 non-static 成員變量(本例為 pMutex )的析構(gòu)函數(shù)。

而 pMutex 的析構(gòu)函數(shù)會(huì)在互斥器的引用次數(shù)為 0 時(shí)，自動(dòng)調(diào)用 std::shared_ptr 的刪除器(本例為 unlock )。

小結(jié) - 請(qǐng)記住

• 復(fù)制 RAII 對(duì)象必須一并復(fù)制它的所管理的資源(深拷貝)，所以資源的 copying 行為決定 RAII 對(duì)象的 copying 行為。
• 普通而常見的 RAII class copying 行為是：禁止 copying、執(zhí)行引用計(jì)數(shù)法。

細(xì)節(jié) 03 ：在資源類中提供對(duì)原始資源的訪問

智能指針「顯式」轉(zhuǎn)換，也就是通過 get 成員函數(shù)的方式轉(zhuǎn)換為原始指針對(duì)象。

上面提到的「智能指針」分別是：std::auto_ptr、std::unique_ptr、std::shared_ptr。它們都有訪問原始資源的辦法，都提供了一個(gè) get 成員函數(shù)，用來執(zhí)行顯式轉(zhuǎn)換，也就是它會(huì)返回智能指針內(nèi)部的原始指針(的復(fù)件)。

舉個(gè)例子，使用智能指針如 std::shared_ptr 保存 createA() 返回的指針對(duì)象 ：

int getInfo(const A* pA); 

你想這么調(diào)用它：

智能指針都重載了指針取值操作符(operator->和operator*)，它們?cè)试S隱式轉(zhuǎn)換至底部原始指針：

所以對(duì)于自身設(shè)計(jì) RAII classes 我們也要提供一個(gè)「取得其所管理的資源」的辦法。

小結(jié) - 請(qǐng)記住

• APIs 往往要求訪問原始資源，所以每一個(gè) RAII class 應(yīng)該提供一個(gè)「取得其所管理的資源」的辦法。
• 對(duì)原始資源的訪問可能經(jīng)由顯式轉(zhuǎn)換或隱式轉(zhuǎn)換。一般而言顯式轉(zhuǎn)換比較安全，但隱式轉(zhuǎn)換比較方便。

細(xì)節(jié) 04：成對(duì)使用 new 和 delete以下動(dòng)作有什么錯(cuò)?

std::string* strArray = new std::string[100]; 
... 
delete strArray; 

每件事情看起來都井然有序。使用了 new，也搭配了對(duì)應(yīng)的 delete。但還是有某樣?xùn)|西完全錯(cuò)誤。strArray 所含的 100 個(gè) string 對(duì)象中的 99 個(gè)不太可能被適當(dāng)刪除，因?yàn)樗鼈兊奈鰳?gòu)函數(shù)很可能沒有被調(diào)用。

當(dāng)使用 new ，有兩件事發(fā)生：

• 內(nèi)存被分配出來(通過名為 operator new 的函數(shù))
• 針對(duì)此內(nèi)存會(huì)有一個(gè)或多個(gè)構(gòu)造函數(shù)被調(diào)用

當(dāng)使用 delete，也會(huì)有兩件事情：

• 針對(duì)此內(nèi)存會(huì)有一個(gè)或多個(gè)析構(gòu)函數(shù)被調(diào)用
• 然后內(nèi)存才被釋放(通過名為 operator delete 的函數(shù))

delete 的最大問題在于：即將被刪除的內(nèi)存之內(nèi)究竟有多少對(duì)象?這個(gè)答案決定了需要執(zhí)行多少個(gè)析構(gòu)函數(shù)。

對(duì)象數(shù)組所用的內(nèi)存通常還包括「數(shù)組大小」的記錄，以便 delete 知道需要調(diào)用多少次析構(gòu)函數(shù)。單一對(duì)象的內(nèi)存則沒有這筆記錄。你可以把兩者不同的內(nèi)存布局想象如下，其中 n 是數(shù)組大?。?/p>

當(dāng)你對(duì)著一個(gè)指針使用 delete，唯一能夠讓 delete 知道內(nèi)存中是否存在一個(gè)「數(shù)組大小記錄」的辦法就是：由你告訴它。如果你使用 delete 時(shí)加上中括號(hào)[]，delete 便認(rèn)定指針指向一個(gè)數(shù)組，否則它便認(rèn)定指針指向一個(gè)單一對(duì)象：

std::string* strArray = new std::string[100]; 
std::string* strPtr = new std::strin; 
...  
delete [] strArray;  // 刪除一個(gè)對(duì)象 
delete strPtr;       // 刪除一個(gè)由對(duì)象組成的數(shù)組 

游戲規(guī)則很簡單：

如果你在 new 表達(dá)式中使用[]，必須在相應(yīng)的 delete 表達(dá)式也使用[]。

如果你在 new 表達(dá)式中不使用[]，一定不要在相應(yīng)的 delete 表達(dá)式使用[]。

小結(jié) - 請(qǐng)記住

• 如果你在 new 表達(dá)式中使用[]，必須在相應(yīng)的 delete 表達(dá)式也使用[]。如果你在 new 表達(dá)式中不使用[]，一定不要在相應(yīng)的 delete 表達(dá)式使用[]。

細(xì)節(jié) 05：以獨(dú)立語句將 newed 對(duì)象置入智能指針

假設(shè)我們有個(gè)以下示范的函數(shù)：

fun(new A(), getNum()); 

它不能通過編譯，因?yàn)?std::shared_ptr 構(gòu)造函數(shù)需要一個(gè)原始指針，而且該構(gòu)造函數(shù)是個(gè) explicit 構(gòu)造函數(shù)，無法進(jìn)行隱式轉(zhuǎn)換。如果寫成這樣就可以編譯通過：

于是在調(diào)用 fun 函數(shù)之前，先必須做以下三件事：

• 調(diào)用 getNum 函數(shù)
• 執(zhí)行 new A 表達(dá)式
• 調(diào)用 std::shared_ptr 構(gòu)造函數(shù)

那么他們的執(zhí)行次序是一定如上述那樣的嗎?可以確定的是 new A 一定比std::shared_ptr 構(gòu)造函數(shù)先被執(zhí)行。但對(duì) getNum 調(diào)用可以排在第一或第二或第三執(zhí)行。

如果編譯器選擇以第二順位執(zhí)行它：

1. 執(zhí)行 new A 表達(dá)式
2. 調(diào)用 getNum 函數(shù)
3. 調(diào)用 std::shared_ptr 構(gòu)造函數(shù)

萬一在調(diào)用 getNum 函數(shù)發(fā)生了異常，會(huì)發(fā)生什么事情?在此情況下 new A 返回的指針將不會(huì)置入 std::shared_ptr 智能指針里，就存在內(nèi)存泄漏的現(xiàn)象。

避免這類問題的辦法很簡單：使用分離語句。

分別寫出：

1. 創(chuàng)建 A
2. 將它置入一個(gè)智能指針內(nèi)
3. 然后再把智能指針傳遞給 fun 函數(shù)。

小結(jié) - 請(qǐng)記住

• 以獨(dú)立語句將 newed (已 new 過) 對(duì)象存儲(chǔ)于智能指針內(nèi)。如果不這樣做，一旦異常被拋出，有可能導(dǎo)致難以察覺的資源泄漏。