「C++ 」借來的資源,何如還的瀟灑?

前言

本文的內容將專門對付內存管理,培養起有借有還的好習慣,方可消除資源管理的問題。程序員


正文

所謂的資源就是,一旦用了它,未來必須還給系統。若是不是這樣,糟糕的事情就會發生。數據庫

C++ 程序內常見的資源:數組

  • 動態分配內存
  • 文件描述符
  • 互斥鎖
  • 圖形頁面中的字型和筆刷
  • 數據庫鏈接
  • 網絡 sockets

不管哪種資源,重要的是,當你再也不使用它時,必須將它還給系統,有借有仍是個好習慣。安全

細節 01 : 以對象管理資源

把資源放在析構函數,交給析構函數釋放資源服務器

假設某個 class 含有個工廠函數,該函數獲取了對象的指針:網絡

A* createA();    // 返回指針,指向的是動態分配對象。
                 // 調用者有責任刪除它。

如上述註釋所言,createA 的調用端使用了函數返回的對象後,有責任刪除它。如今考慮有個f函數履行了這個責任:app

void f()
{
    A *pa = createA();  // 調用工廠函數
    ...                 // 其餘代碼
    delete pa;          // 釋放資源
}

這看起來穩妥,但存在若干狀況f函數可能沒法執行到delete pa語句,也就會形成資源泄漏,例如以下狀況:socket

  • 或許由於「…」區域內的一個過早的 return 語句;
  • 或許由於「…」區域內的一個循環語句過早的continue 或 goto 語句退出;
  • 或許由於「…」區域內的語句拋出異常,沒法執行到 delete。

固然能夠經過謹慎地編寫程序能夠防止這一類錯誤,但你必須想一想,代碼可能會在時間漸漸過去後被修改,若是是一個新手沒有注意這一類狀況,那必然又會再次有內存泄漏的可能性。函數

爲確保 A 返回的資源都是被回收,咱們須要將資源放進對象內,當對象離開做用域時,該對象的析構函數會自動釋放資源。佈局

「智能指針」是個好幫手,交給它去管理指針對象。

對因而由動態分配(new)於堆內存的對象,指針對象離開了做用域並不會自動調用析構函數(需手動delete),爲了讓指針對象能像普通對象同樣,離開做用域自動調用析構函數回收資源,咱們須要藉助「智能指針」的特性。

經常使用的「智能指針」有以下三個:

  • std::auto_ptr( C++ 98 提供、C++ 11 建議摒棄不用 )
  • std::unique_ptr( C++ 11 提供 )
  • std::shared_ptr( C++ 11 提供 )
std::auto_ptr

下面示範如何使用 std::auto_ptr 以免 f 函數潛在的資源泄漏可能性:

void f()
{
    std::auto_ptr<A> pa (createA()); // 調用工廠函數
    ...  // 一如既往的使用pa
}        // 離開做用域後,經由 auto_ptr 的析構函數自動刪除pa;

這個簡單的例子示範「以對象管理資源」的兩個關鍵想法:

  • 得到資源後馬上放進管理對象內。以上代碼中 createA 返回的資源被當作其管理者 auto_ptr 的初值,也就馬上被放進了管理對象中。
  • 管理對象運用析構函數確保資源釋放。不論控制流如何離開區塊,一旦對象被銷燬(例如當對象離開做用域)其析構函數天然會被自動調用,因而資源被釋放。

爲何在 C++11 建議棄用 auto_ptr 嗎?固然是 auto_ptr 存在缺陷,因此後續不被建議使用。

auto_ptr 有一個不尋常的特質:若經過「複製構造函數或賦值操做符函數」 copy 它們,它們會變成 null ,而複製所得的指針將獲取資源的惟一擁有權!
見以下例子說明:

std::auto_ptr<A> pa1(createA()); // pa1 指向 createA 返回物

std::auto_ptr<A> pa2(pa1); // 如今 pa2 指向對象,pa1將被設置爲 null

pa1 = pa2; // 如今 pa1 指向對象,pa2 將被設置爲 null

這一詭異的複製行爲,若是再次使用指向爲 null 的指針,那必然會致使程序奔潰
意味着 auto_ptr 並不是管理動態分配資源的神兵利器。

std::unique_ptr

unique_ptr 也採用全部權模型,可是在使用時,是直接禁止經過複製構造函數或賦值操做符函數 copy 指針對象,以下例子在編譯時,會出錯:

std::unique_ptr<A> pa1(createA()); // pa1 指向 createA 返回物

std::unique_ptr<A> pa2(pa1); // 編譯出錯!

pa1 = pa2; // 編譯出錯!
std::shared_ptr

shared_ptr 在使用複製構造函數或賦值操做符函數後,引用計會數累加而且兩個指針對象指向的都是同一個塊內存,這就與 unique_ptr、auto_ptr 不一樣之處。

void f()
{
    std::shared_ptr<A> pa1(createA()); // pa1 指向 createA 返回物

    std::shared_ptr<A> pa2(pa1); // 引用計數+1,pa2和pa1指向同一個內存

    pa1 = pa2; // 引用計數+1,pa2和pa1指向同一個內存
}

當一個對象離開做用域,shared_ptr 會把引用計數值 -1 ,直到引用計數值爲 0 時,纔會進行刪除對象。

因爲 shared_ptr 釋放空間時會事先要判斷引用計數值的大小,所以不會出現屢次刪除一個對象的錯誤。

小結 - 請記住

  • 爲防止資源泄漏,請使用 RAII(Resource Acquisition Is Initaliaztion - 資源取得時機即是初始化時機) 對象,它們在構造函數中獲取資源,並在析構函數中是釋放資源
  • 兩個建議使用的 RAII classes 分別是 std::unique_ptr 和 std::shared_ptr。前者不容許 copy 動做,後者容許 copy 動做。可是不建議用 std::auto_ptr,若選 auto_ptr,複製動做會使它(被複制物)指向 null 。

細節 02:在資源管理類中當心 copying 行爲

假設,咱們使用 C 語音的 API 函數處理類型爲 Mutex 的互斥對象,共有 lock 和 unlock 兩函數可用:

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

爲確保毫不會忘記一個被鎖住的 Mutex 解鎖,咱們可能會但願創立一個 class 來管理鎖資源。這樣的 class 要遵照 RAII 守則,也就是「資源在構造期間得到,在析構釋放期間釋放」:

class Lock
{
public:
    explicit Lock(Mutex *pm) // 構造函數
        : pMutex(pm)
    {
        lock(pMutex);
    }

    ~Lock()  // 析構函數
    {
        unlock(pMutex);
    }
private:
    Mutex* pMutex;
};

這樣定義的 Lock,用法符合 RAII 方式:

Mutex m;      //定義你須要的互斥鎖
... 
{                 // 創建一個局部區塊做用域
    Lock m1(&m);  // 鎖定互斥器
    ...
}                 // 在離開區塊做用域,自動解除互斥器鎖定

這很好,但若是 Lock 對象被複制,會發生什麼事情?

Lock m1(&m);  // 鎖定m
Lock m2(&m1); // 將 m1 複製到 m2身上,這會發生什麼?

這是咱們須要思考和麪對的:「當一個 RAII 對象被複制,會發生什麼事情?」大多數時候你會選擇如下兩種可能:

  • 禁止複製。若是 RAII 不容許被複制,那咱們須要將 class 的複製構造函數和賦值操做符函數聲明在 private。
  • 使用引用計數法。有時候咱們但願保有資源,直到它直的最後一個對象被消耗。這種狀況下複製 RAII 對象時,應該將資源的「被引用數」遞增。std::shared_ptr 即是如此。

若是前述的 Lock 打算使用使用引用計數法,它可使用 std::shared_ptr 來管理 pMutex 指針,而後很不幸 std::shared_ptr 的默認行爲是「當引用次數爲 0 時刪除其所指物」那不是咱們想要的行爲,由於要對 Mutex 釋放動做是解鎖而非刪除。

幸運的是 std::shared_ptr 容許指定自定義的刪除方式,那是一個函數或函數對象。以下:

class Lock
{
public:
    explicit Lock(Mutex *pm)  
        : pMutex(pm, unlock)  // 以某個 Mutex 初始化 shared_ptr,
                              // 並以 unlock 函數爲刪除器。
    {
        lock(pMutex.get());  // get 獲取指針地址
    }

private:
    std::shared_ptr<Mutex> pMutex; // 使用 shared_ptr
};

請注意,本例的 Lock class 再也不聲明析構函數。由於編譯器會自動創立默認的析構函數,來自動調用其 non-static 成員變量(本例爲 pMutex )的析構函數。

而 pMutex 的析構函數會在互斥器的引用次數爲 0 時,自動調用 std::shared_ptr 的刪除器(本例爲 unlock )

小結 - 請記住

  • 複製 RAII 對象必須一併複製它的所管理的資源(深拷貝),因此資源的 copying 行爲決定 RAII 對象的 copying 行爲。
  • 普通而常見的 RAII class copying 行爲是:禁止 copying、施行引用計數法。

細節 03 :在資源類中提供對原始資源的訪問

智能指針「顯式」轉換,也就是經過 get 成員函數的方式轉換爲原始指針對象。

上面提到的「智能指針」分別是:std::auto_ptr、std::unique_ptr、std::shared_ptr。它們都有訪問原始資源的辦法,都提供了一個 get 成員函數,用來執行顯式轉換,也就是它會返回智能指針內部的原始指針(的復件)

舉個例子,使用智能指針如 std::shared_ptr 保存 createA() 返回的指針對象 :

std::shared_ptr<A> pA(createA());

假設你但願以某個函數處理 A 對象,像這樣:

int getInfo(const A* pA);

你想這麼調用它:

std::shared_ptr<A> pA(createA());
getInfo(pA);       // 錯誤!!

會編譯錯誤,由於 getInfo 須要的是 A 指針對象,而不是類型爲 std::shared_ptr<A> 的對象。

這時候就須要用 std::shared_ptr 智能指針提供的 get 成員函數訪問原始的資源:

std::shared_ptr<A> pA(createA());
getInfo(pA.get());   // 很好,將 pA 內的原始指針傳遞給 getInfo

智能指針「隱式」轉換的方式,是經過指針取值操做符。

智能指針都重載了指針取值操做符(operator->和operator*),它們容許隱式轉換至底部原始指針:

class A
{
publicbool isExist() const;
    ...
};

A* createA();  // 工廠函數,建立指針對象

std::shared_ptr<A> pA(createA()); // 令 shared_ptr 管理對象資源

bool exist = pA->isExist();    // 經由 operator-> 訪問資源
bool exist2 = (*pA).isExist(); // 經由 operator* 訪問資源

多數設計良好的 classes 同樣,它隱藏了程序員不須要看到的部分,可是有程序員須要的全部東西。

因此對於自身設計 RAII classes 咱們也要提供一個「取得其所管理的資源」的辦法。

小結 - 請記住

  • APIs 每每要求訪問原始資源,因此每個 RAII class 應該提供一個「取得其所管理的資源」的辦法。
  • 對原始資源的訪問可能經由顯式轉換或隱式轉換。通常而言顯式轉換比較安全,但隱式轉換比較方便。

細節 04:成對使用 new 和 delete

如下動做有什麼錯?

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

每件事情看起來都井井有理。使用了 new,也搭配了對應的 delete。但仍是有某樣東西徹底錯誤。strArray 所含的 100 個 string 對象中的 99 個不太可能被適當刪除,由於它們的析構函數極可能沒有被調用。

當使用 new ,有兩件事發生:

  • 內存被分配出來(經過名爲 operator new 的函數)
  • 針對此內存會有一個或多個構造函數被調用

當使用 delete,也會有兩件事情:

  • 針對此內存會有一個或多個析構函數被調用
  • 而後內存才被釋放(經過名爲 operator delete 的函數)

delete 的最大問題在於:即將被刪除的內存以內究竟有多少對象?這個答案決定了須要執行多少個析構函數。

對象數組所用的內存一般還包括「數組大小」的記錄,以便 delete 知道須要調用多少次析構函數。單一對象的內存則沒有這筆記錄。你能夠把二者不一樣的內存佈局想象以下,其中 n 是數組大小:

當你對着一個指針使用 delete,惟一可以讓 delete 知道內存中是否存在一個「數組大小記錄」的辦法就是:由你告訴它。若是你使用 delete 時加上中括號[],delete 便認定指針指向一個數組,不然它便認定指針指向一個單一對象:

std::string* strArray = new std::string[100];
std::string* strPtr = new std::strin;
... 
delete [] strArray;  // 刪除一個對象
delete strPtr;       // 刪除一個由對象組成的數組

遊戲規則很簡單:

  • 若是你在 new 表達式中使用[],必須在相應的 delete 表達式也使用[]
  • 若是你在 new 表達式中不使用[],必定不要在相應的 delete 表達式使用[]

小結 - 請記住

  • 若是你在 new 表達式中使用[],必須在相應的 delete 表達式也使用[]。若是你在 new 表達式中不使用[],必定不要在相應的 delete 表達式使用[]。

細節 05:以獨立語句將 newed (已被 new 的)對象置入智能指針

假設咱們有個如下示範的函數:

int getNum();
void fun(std::shared_ptr<A> pA, int num);

如今考慮調用 fun:

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

它不能經過編譯,由於 std::shared_ptr 構造函數須要一個原始指針,並且該構造函數是個 explicit 構造函數,沒法進行隱式轉換。若是寫成這樣就能夠編譯經過:

fun(std::shared_ptr<A>(new A), getNum());

使人想不到吧,上述調用卻可能泄露資源。接下來咱們來一步一步的分析爲何存在內存泄漏的可能性。

在進入 fun 函數以前,確定會先執行各個實參。上述第二個實參只是單純的對 getNum 函數的調用,但第一個實參 std::shared_ptr<A>(new A) 由兩部分組成:

  • 執行 new A 表達式
  • 調用 std::shared_ptr 構造函數

因而在調用 fun 函數以前,先必須作如下三件事:

  • 調用 getNum 函數
  • 執行 new A 表達式
  • 調用 std::shared_ptr 構造函數

那麼他們的執行次序是必定如上述那樣的嗎?能夠肯定的是 new A 必定比 std::shared_ptr 構造函數先被執行。但對 getNum 調用能夠排在第一或第二或第三執行。

若是編譯器選擇以第二順位執行它:

  1. 執行 new A 表達式
  2. 調用 getNum 函數
  3. 調用 std::shared_ptr 構造函數
    萬一在調用 getNum 函數發生了異常,會發生什麼事情?在此狀況下 new A 返回的指針將不會置入 std::shared_ptr 智能指針裏,就存在內存泄漏的現象

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

分別寫出:

  1. 建立 A
  2. 將它置入一個智能指針內
  3. 而後再把智能指針傳遞給 fun 函數。
std::shared_ptr<A> pA(new A); // 先構造智能指針對象
fun(pA, getNum()); // 這個調用動做毫不至於形成泄漏。

以上的方式,就能避免本來因爲次序致使內存泄漏發生。

小結 - 請記住

  • 以獨立語句將 newed (已 new 過) 對象存儲於智能指針內。若是不這樣作,一旦異常被拋出,有可能致使難以察覺的資源泄漏。

最後

本文部份內容參考了《Effective C++ (第3版本)》第三章節內容,前兩章節的內容可看舊文
學過 C++ 的你,不得不知的這 10 條細節!


關注公衆號,後臺回覆「我要學習」,便可免費獲取精心整理「服務器 Linux C/C++ 」成長路程(書籍資料 + 思惟導圖)

相關文章
相關標籤/搜索