專案介紹
記憶體洩漏一直是 C++ 中比較令人頭大的問題， 即便是很有經驗的 C++程式設計師有時候也難免因為疏忽而寫出導致記憶體洩漏的程式碼。除了基本的申請過的記憶體未釋放外，還存在諸如異常分支導致的記憶體洩漏等等。本專案將使用 C++ 實現一個記憶體洩漏檢查器。

專案涉及的知識點

1.new 操作符過載
2.__FILE__、__LINE__ 預定義巨集
3.標頭檔案中的靜態變數
4.std::shared_ptr 智慧指標

記憶體洩漏通常是由於疏忽而導致的申請記憶體未釋放。在現代作業系統中，一個應用程式使用的常規記憶體終止後這些未釋放的記憶體仍然會被作業系統回收，所以一個短暫執行的應用程式而導致的記憶體洩漏不會造成比較嚴重的後果。

但是，如果我們在編寫諸如伺服器一類的應用時，它會始終保持執行狀態，如果一旦存在發生記憶體洩露的邏輯，將很有可能繼續造成洩露的記憶體增加，從而嚴重降低計算機效能，甚至導致系統執行故障等。

一個長期執行並不斷佔用記憶體的程式非常簡單：

int main() {
    // 始終保持記憶體申請，但永不釋放
    while(1){
    //死迴圈
       int *a = new int;          }
    return 0;
}

要檢測一個長期執行的程式是否發生記憶體洩露通常是在應用中設定檢查點，分析不同檢查點中記憶體是否長期保持佔用而未釋放，從本質上來說，這與對一個短期執行的程式進行記憶體洩露檢查是非常類似的。所以本專案中的記憶體洩漏檢查器將實現一個用於短期記憶體洩露的檢查器。

我們不妨編寫下面的測試程式碼用於檢測我們的記憶體洩露，在這個程式碼中，我們刻意的不去釋放某個申請的記憶體，並刻意的去製造一個異常分支產生的記憶體洩露。

例如：
main.cpp

#include <iostream>

// 在這裡實現記憶體洩露檢查
#include "LeakDetector.hpp"

// 測試異常分支洩露
class Err {
public:
    Err(int n) {
        if(n == 0) throw 1000;
        data = new int[n];
    }
    ~Err() {
        delete[] data;
    }
private:
    int *data;
};

int main() {

    // 忘記釋放指標 b 申請的記憶體，從而導致記憶體洩露
    int *a = new int;
    int *b = new int;
    delete a;

    // 0 作為引數傳遞給建構函式將發生異常，從而導致異常分支的記憶體洩露
    try {
        Err* e = new Err(0);
        delete e;
    } catch (int &ex) {
        std::cout << "Exception catch: " << ex << std::endl;
    };
    return 0;

}
 

先註釋掉

//#include "LeakDetector.hpp"

那麼這段程式碼能夠正常的被執行，如下圖所示。但我們知道，這段程式碼中其實是發生了記憶體洩露的：

要實現記憶體洩露的檢查，我們可以從下面幾個點來思考：

記憶體洩露產生於 new 操作進行後沒有執行 delete
最先被建立的物件，其解構函式永遠是最後執行的
對應這兩點，我們可以做下面的操作：

過載 new 運算子
建立一個靜態物件，用於在原始程式退出時候才呼叫這個靜態物件的解構函式
這樣兩個步驟的好處在於：無需修改原始程式碼的情況下，就能進行記憶體檢查。這同時也是我們希望看到的。所以，我們可以在 LeakDetector.hpp 裡首先實現：

#ifndef __LEAK_DETECTOR__
#define __LEAK_DETECTOR__

void* operator new(size_t _size, char *_file, unsigned int _line);
void* operator new[](size_t _size, char *_file, unsigned int _line);
// 此處巨集的作用下一節實現 LeakDetector.cpp 時說明
#ifndef __NEW_OVERLOAD_IMPLEMENTATION__
#define new    new(__FILE__, __LINE__)
#endif

class _leak_detector
{
public:
    static unsigned int callCount;
    _leak_detector() noexcept {
        ++callCount;
    }
    ~_leak_detector() noexcept {
        if (--callCount == 0)
            LeakDetector();
    }
private:
    static unsigned int LeakDetector() noexcept;
};
static _leak_detector _exit_counter;

為什麼要設計 callCount? callCount 保證了我們的 LeakDetector 只調用了一次。考慮下面的簡化程式碼：

// main.cpp
#include <iostream>
#include "test.h"
int main() {
    return 0;
}

// test.hpp
#include <iostream>
class Test {
public:
    static unsigned int count;
    Test() {
        ++count;
        std::cout << count << ", ";
    }
};
static Test test;

// test.cpp
#include "test.hpp"
unsigned int Test::count = 0;

最後的輸出結果為 1, 2,

這是因為在標頭檔案中的靜態變數會被多次定義，每包含一次，都會在某個 .cpp 中被定義（這裡則在 main.cpp 和 test.cpp 中均有定義），但實際上他們均為同名，本質上還是同一個物件。

那麼現在的問題就只剩下了：如何實現記憶體洩露的檢測？

下面我們來逐步實現這個記憶體洩露檢查器。

既然我們已經過載了 new 操作符，那麼我們很自然就能想到通過手動管理記憶體申請和釋放，如果我們 delete 時沒有將申請的記憶體全部釋放完畢，那麼一定發生了記憶體洩露。接下來一個問題就是，使用什麼結構來實現手動管理記憶體？

不妨使用雙向連結串列來實現記憶體洩露檢查。原因在於，對於記憶體檢查器來說，並不知道實際程式碼在什麼時候會需要申請記憶體空間，所以使用線性表並不夠合理，一個動態的結構（連結串列）是非常便捷的。而我們在刪除記憶體檢查器中的物件時，需要更新整個結構，對於單向連結串列來說，也是不夠便利的。

建立LeakDetector.cpp檔案

#include <iostream>
#include <cstring>

// 在此處定義 _DEBUG_NEW_ 巨集, 
// 從而在這個實現檔案中不再繼續過載 new 運算子, 
// 從而防止編譯衝突
#define __NEW_OVERLOAD_IMPLEMENTATION__
#include "LeakDetector.hpp"

typedef struct _MemoryList {
    struct  _MemoryList *next, *prev;
    size_t     size;       // 申請記憶體的大小
    bool    isArray;    // 是否申請了陣列
    char    *file;      // 儲存所在檔案
    unsigned int line;  // 儲存所在行
} _MemoryList;
static unsigned long _memory_allocated = 0;     // 儲存未釋放的記憶體大小
static _MemoryList _root = {
    &_root, &_root, // 第一個元素的前向後向指標均指向自己
    0, false,               // 其申請的記憶體大小為 0, 且不是陣列
    NULL, 0                 // 檔案指標為空, 行號為0
};

unsigned int _leak_detector::callCount = 0;
// 從 _MemoryList 頭部開始分配記憶體
void* AllocateMemory(size_t _size, bool _array, char *_file, unsigned _line) {
    // 計算新的大小
    size_t newSize = sizeof(_MemoryList) + _size;

    // 由於 new 已經被過載，我們只能使用 malloc 來分配記憶體
    _MemoryList *newElem = (_MemoryList*)malloc(newSize);

    newElem->next = _root.next;
    newElem->prev = &_root;
    newElem->size = _size;
    newElem->isArray = _array;
    newElem->file = NULL;

    // 如果有檔案資訊，則儲存下來
    if (_file) {
        newElem->file = (char *)malloc(strlen(_file)+1);
        strcpy(newElem->file, _file);
    }
    // 儲存行號
    newElem->line = _line;

    // 更新列表
    _root.next->prev = newElem;
    _root.next = newElem;

    // 記錄到未釋放記憶體數中
    _memory_allocated += _size;

    // 返回申請的記憶體，將 newElem 強轉為 char* 來嚴格控制指標每次 +1 只移動一個 byte
    return (char*)newElem + sizeof(_MemoryList);
}

void  DeleteMemory(void* _ptr, bool _array) {
    // 返回 MemoryList 開始處
    _MemoryList *currentElem = (_MemoryList *)((char *)_ptr - sizeof(_MemoryList));

    if (currentElem->isArray != _array) return;

    // 更新列表
    currentElem->prev->next = currentElem->next;
    currentElem->next->prev = currentElem->prev;
    _memory_allocated -= currentElem->size;

    // 記得釋放存放檔案資訊時申請的記憶體
    if (currentElem->file) free(currentElem->file);
    free(currentElem);
}

// 過載 new 運算子
void* operator new(size_t _size) {
    return AllocateMemory(_size, false, NULL, 0);
}
void* operator new[](size_t _size) {
    return AllocateMemory(_size, true, NULL, 0);
}
void* operator new(size_t _size, char *_file, unsigned int _line) {
    return AllocateMemory(_size, false, _file, _line);
}
void* operator new[](size_t _size, char *_file, unsigned int _line) {
    return AllocateMemory(_size, true, _file, _line);
}
// 過載 delete 運算子
void operator delete(void *_ptr) noexcept {
    DeleteMemory(_ptr, false);
}
void operator delete[](void *_ptr) noexcept {
    DeleteMemory(_ptr, true);
}
unsigned int _leak_detector::LeakDetector(void) noexcept {
    unsigned int count = 0;
    // 遍歷整個列表, 如果有記憶體洩露，那麼 _LeakRoot.next 總不是指向自己的
    _MemoryList *ptr = _root.next;
    while (ptr && ptr != &_root)
    {
        // 輸出存在記憶體洩露的相關資訊, 如洩露大小, 產生洩露的位置
        if(ptr->isArray)
            std::cout << "leak[] ";
        else
            std::cout << "leak   ";
        std::cout << ptr << " size " << ptr->size;
        if (ptr->file)
            std::cout << " (locate in " << ptr->file << " line " << ptr->line << ")";
        else
            std::cout << " (Cannot find position)";
        std::cout << std::endl;

        ++count;
        ptr = ptr->next;
    }

    if (count)
        std::cout << "Total " << count << " leaks, size "<< _memory_allocated << " byte." << std::endl;
    return count;
}

最後編譯我們的程式碼，輸入：

g++ main.cpp LeakDetector.cpp -std=c++11 -Wno-write-strings

我們通過過載 new 運算子，實現了記憶體洩露檢查器

事實上，這個程式碼同樣可以用於 C++11 中智慧指標迴圈引用產生的記憶體洩露，將 main.cpp 修改為：

#include <memory> // 使用智慧指標

// ...前面不做修改

// 增加兩個測試類
class A;
class B;
class A {
public:
    std::shared_ptr<B> p;
};
class B {
public:
    std::shared_ptr<A> p;
};

int main() {

    //...前面不做修改

    // 智慧指標迴圈引用導致的記憶體洩露
    auto smartA = std::make_shared<A>();
    auto smartB = std::make_shared<B>();
    smartA->p = smartB;
    smartB->p = smartA;

    return 0;

}

結果如下

不過其缺陷在於無法獲得洩露的定位，這是由於我們只把 FILE 和 LINE 巨集嵌入到了 new 操作符中，而 make_shared 並沒有進行指定。