C++ 內(nèi)存管理（一）

導(dǎo)語

c++ 內(nèi)存管理學(xué)習(xí)自侯捷。

下面是本次對C++內(nèi)存管理一些筆記。

1.四種內(nèi)存分配與釋放

在編程時可以通過上圖的幾種方法直接或間接地操作內(nèi)存。下面將介紹四種C++內(nèi)存操作方法：

對于GNU C：四種分配與釋放方式如下：

   // C函數(shù)   void *p1 = malloc(512);   *(int *) p1 = 100;   cout << *(int *) p1 << endl;   free(p1);
   // C++表達(dá)式   int *p2 = new int(10);   cout << *p2 << endl;   delete p2;
   // C++函數(shù) 實際上等價于上述malloc與free   void *p3 = ::operator new(512);   *(int *) p3 = 103;   cout << *(int *) p3 << endl;  ::operator delete(p3);
   //C++標(biāo)準(zhǔn)庫   printf("hello gcc %d\n", __GNUC__);#ifdef __GNUC__// 以下函數(shù)都是non-static,一定要通過object調(diào)用，以下分配7個單元，而不是7個字節(jié)   int *p4 = allocator<int>().allocate(7);   *p4 = 9;   cout << *p4 << endl;   allocator<int>().deallocate((int *) p4, 7);
   /**    * void *p = alloc::allocate(512); 分配512bytes    * alloc::deallocate(p,512);    */   // __pool_alloc等價于之前的alloc 9個單元   int *p5 = __gnu_cxx::__pool_alloc<int>().allocate(9);   *p5 = 10;   cout << *p5 << endl;   __gnu_cxx::__pool_alloc<int>().deallocate((int *) p5, 9);#endif

2.new/delete表達(dá)式

2.1 new表達(dá)式

當(dāng)使用operator new：

// 下面這個是new expression,而operator new 是函數(shù)Complex* pc = new Complex(1,2);

上述會被編譯器轉(zhuǎn)為：

Complex *pc;try {// operator new 實現(xiàn)自 new_op.cc   void* mem = operator new(sizeof(Complex)); //allocate 分配內(nèi)存   pc = static_cast<Complex*>(mem);    // cast 轉(zhuǎn)型 以符合對應(yīng)的類型，這里對應(yīng)為Complex*   pc->Complex::Complex(1,2); // construct   // 注意：只有編譯器才可以像上面那樣直接呼叫ctor 欲直接調(diào)用ctor可通用placement new: new(p) Complex(1,2);}catch(std::bad_alloc) {   // 若allocation失敗就不執(zhí)行constructor}

new操作背后編譯器做的事：

• 第一步通過operator new()操作分配一個目標(biāo)類型的內(nèi)存大小，這里是Complex的大小；

• 第二步通過static_cast將得到的內(nèi)存塊強(qiáng)制轉(zhuǎn)換為目標(biāo)類型指針，這里是Complex*

• 第三版調(diào)用目標(biāo)類型的構(gòu)造方法，但是需要注意的是，直接通過pc->Complex::Complex(1, 2)這樣的方法調(diào)用構(gòu)造函數(shù)只有編譯器可以做，用戶這樣做將產(chǎn)生錯誤。

注意：operator new()操作的內(nèi)部是調(diào)用了malloc()函數(shù)。

operator new()具體實現(xiàn)源代碼見：

https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/new_op.cc

2.2 delete表達(dá)式

對于上述delete調(diào)用，

delete pc;pc->~Complex();  //先析構(gòu)operator delete(pc);   //然后釋放內(nèi)存

delete操作步驟：

• 第一步調(diào)用了對象的析構(gòu)函數(shù)

• 第二步通過operator delete()函數(shù)釋放內(nèi)存，本質(zhì)上也是調(diào)用了free函數(shù)。

operator delete()具體實現(xiàn)源代碼見：

https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/del_op.cc

3.1 array

上圖主要展示的是關(guān)于array new內(nèi)存分配的大致情況。

當(dāng)new一個數(shù)組對象時（例如 new Complex[3]），編譯器將分配一塊內(nèi)存，這塊內(nèi)存首部是關(guān)于對象內(nèi)存分配的一些標(biāo)記，然后下面會分配三個連續(xù)的對象內(nèi)存，在使用delete釋放內(nèi)存時需要使用delete[]。

什么情況下發(fā)生內(nèi)存泄露？

如果不使用delete[]，只是使用delete只會將分配的三塊內(nèi)存空間釋放，但不會調(diào)用對象的析構(gòu)函數(shù)，如果對象內(nèi)部還使用了new指向其他空間，如果指向的該空間里的對象的析構(gòu)函數(shù)沒有意義，那么不會造成問題，如果有意義，那么由于該部分對象析構(gòu)函數(shù)不會調(diào)用，那么將會導(dǎo)致內(nèi)存泄漏。

圖中new string[3]便是一個例子，雖然str[0]、str[1]、str[2]被析構(gòu)了，但只是調(diào)用了str[0]的析構(gòu)函數(shù)，其他對象的析構(gòu)函數(shù)不被調(diào)用，這里就會出問題。

其中的cookie保存的是delete[]里面的數(shù)據(jù)，比如delete幾次。

3.2 演示數(shù)組對象創(chuàng)建與析構(gòu)過程

構(gòu)造函數(shù)調(diào)用順序是按照構(gòu)建對象順序來執(zhí)行的，但是析構(gòu)函數(shù)執(zhí)行卻相反。

構(gòu)造函數(shù)：自上而下；析構(gòu)函數(shù)：自下而上。

3.3 malloc基本構(gòu)成

如果使用new分配十個內(nèi)存的int，內(nèi)存空間如上圖所示，首先內(nèi)存塊會有一個頭和尾，黃色部分為debug信息，灰色部分才是真正使用到的內(nèi)存，藍(lán)色部分的12bytes是為了讓該內(nèi)存塊以16字節(jié)對齊。在這個例子中delete pi和delete[] pi效果是一樣的，因為int沒有析構(gòu)函數(shù)。但是如果釋放的對象的析構(gòu)函數(shù)有意義，array delet就必須采用delete[]，否則發(fā)生內(nèi)存泄露。

4.placement new

char *buf = new char[sizeof(Complex) * 3];Complex *pc = new(buf)Complex(1, 2);delete[]buf;

上述被編譯器編譯為：

Complex *pc;try   void* mem = operator new(sizeof(Complex),buf); //allocate   pc= static_cast<Complex*>(mem);//cast   pc->Complex::Complex(1,2);//construct} catch (std::bad_alloc) {   // 若allocation失敗就不執(zhí)行construct}

值得注意的是，這里采用的operator new有兩個參數(shù)，我們在下面源碼中：

https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/new

看到：

_GLIBCXX_NODISCARD inline void* operator new(std::size_t, void* __p) _GLIBCXX_USE_NOEXCEPT{ return __p; }

因此得出，沒有做任何事，直接返回buf， 因此placement new 就等同于調(diào)用構(gòu)造函數(shù)。也沒有所謂的operator delete ,因為placement new根本沒有分配memory。

5.重載

5.1 C++內(nèi)存分配的途徑

如果是正常情況下，調(diào)用new之后走的是第二條路線，如果在類中重載了operator new()，那么走的是第一條路線，但最后還是要調(diào)用到系統(tǒng)的::operator new()函數(shù)，這在后續(xù)的例子中會體現(xiàn)。

對于GNU C，背后使用的allocate()函數(shù)最后也是調(diào)用了系統(tǒng)的::operator new()函數(shù)。

5.2 重載new 和 delete

上面這張圖演示了如何重載系統(tǒng)的::operator new()函數(shù)，該方法最后也是模擬了系統(tǒng)的做法，效果和系統(tǒng)的方法一樣，但一般不推薦重載::operator new()函數(shù)，因為它對全局有影響，如果使用不當(dāng)將造成很大的問題。

如果是在類中重載operator new()方法，那么該方法有N多種形式，但必須保證函數(shù)參數(shù)列表第一個參數(shù)是size_t類型變量；對于operator delete()，第一個參數(shù)必須是void* 類型，第二個size_t是可選項，可以去掉。

對于operator new[]和operator delete[]函數(shù)的重載，和前面類似。

6.pre-class allocator1

前面把基本元素的重載元素學(xué)完了，例如：new、operator new、array new等等。萬事俱備，現(xiàn)在可以開始一個class進(jìn)行內(nèi)存管理。

對于malloc來說，大家都有一個誤解，以為它很慢，其實它不慢，后面會講到。無論如何，減少malloc的調(diào)用次數(shù)，總是很好的，所以設(shè)計class者，可以先挖一塊，只使用一次malloc，使用者使用，就只需要調(diào)用一次malloc，這樣就是一個小型的內(nèi)存管理。

除了降低malloc次數(shù)之外，還需要降低cookie用量。前面提到一次malloc需要一組(兩個)cookie，總共8字節(jié)。

所以，如果一次要1000個大小，這1000個切下來，都是不帶cookie，只有1000個一整包上下帶cookie。所以內(nèi)存池的設(shè)計就是一整塊，一個池塘。這一大塊設(shè)計不但要提升速度，而且要降低浪費率。所以內(nèi)存管理目標(biāo)就是，一個是速度，一個是空間。

每次挖一大塊，需要指針把他們穿起來，如下圖右邊鏈表結(jié)構(gòu)，基于這個考量，下面例子中設(shè)計了next指針。此時碰到了一個困惑：多設(shè)計了一個指針，去除了cookie，卻膨脹率100%(int i 占4字節(jié)，指針也是4字節(jié))。

使用者使用new的時候，就會被接管到operator new這個函數(shù)來，delete類似。

分配：operator new就是挖一大塊，里面主要做的就是指針操作與轉(zhuǎn)型。其中freeStore指向頭，operator new返回的就是freeStore表頭。

回收：當(dāng)使用者delete一個Scree，就會先調(diào)用析構(gòu)函數(shù)，然后調(diào)用釋放內(nèi)存函數(shù)，operator delete接管了這個任務(wù)，接收到一個指針。就把這個鏈表回收到單向鏈表之中。單向鏈表始終都有一個頭，所以回收動作最快放在鏈表開頭。

7.pre-class allocator2

這里與上述不同之處在于使用union設(shè)計，這里帶來了一個觀念：嵌入式指針，embedding pointer。

分配與釋放同前面6。

嵌入式指針：rep占16字節(jié)，next占前8字節(jié)。

union {   AirplaneRep rep;  //此針對 used object   Airplane* next;   //此針對 free list};

借用一個東西的前8字節(jié)當(dāng)指針用，這樣整體上可以節(jié)省空間，這是一個很好的想法，在內(nèi)存管理中都是這么來用。

最后，6與7中的operator delete并沒有free掉，只是回收到單向鏈表中。這樣子好？

這種當(dāng)然不好，技術(shù)難點非常高，后面談！雖然沒有還給操作系統(tǒng)，但不能說它內(nèi)存泄露，因為這些都在它的"手上"。

8.static allocator3

不要把內(nèi)存分配與回收寫在各個class中，而要把它們集中在一個allocator中！

在前面設(shè)計中，每次都需要重載相應(yīng)的函數(shù)，內(nèi)部處理一些邏輯，重復(fù)代碼量多，我們可以將這些包裝起來，使它容易被重復(fù)使用。以下展示一個作法：每個allocator object都是個分配器，在allocator設(shè)計了allocate與deallocate兩個函數(shù)。，它內(nèi)部設(shè)計如下：

class allocator{private:   struct obj {       struct obj* next;  //embedded pointer  };public:   void* allocate(size_t);   void  deallocate(void*, size_t);   void  check();
private:   obj* freeStore = nullptr;   const int CHUNK = 5; //小一點方便觀察 標(biāo)準(zhǔn)庫里面是20};

其他類，例如：Foo和Goo，當(dāng)需要allocator這種內(nèi)存管理池，只需要寫出下面兩個函數(shù)：

static void* operator new(size_t size){   return myAlloc.allocate(size);}static void  operator delete(void* pdead, size_t size){   return myAlloc.deallocate(pdead, size);}

然后把內(nèi)部做的動作交給myAlloc。myAlloc是專門為Foo或者Goo之類的服務(wù)的，可以設(shè)計為靜態(tài) ：

static allocator myAlloc;

想象成里面有一根指針指向一條鏈表，專門為自己服務(wù)。

這里實現(xiàn)同前面的實現(xiàn)。

void* allocator::allocate(size_t size){   obj* p;
   if (!freeStore) {       //linked list 是空的，所以攫取一大塊 memory       size_t chunk = CHUNK * size;       freeStore = p = (obj*)malloc(chunk);
       //cout << "empty. malloc: " << chunk << " " << p << endl;
       //將分配得來的一大塊當(dāng)做 linked list 般小塊小塊串接起來       for (int i = 0; i < (CHUNK - 1); ++i) {  //沒寫很漂亮, 不是重點無所謂.             p->next = (obj*)((char*)p + size);           p = p->next;      }       p->next = nullptr;  //last        }   p = freeStore;   freeStore = freeStore->next;
   //cout << "p= " << p << " freeStore= " << freeStore << endl;
   return p;}

同前面實現(xiàn)：

void allocator::deallocate(void* p, size_t){   //將 deleted object 收回插入 free list 前端  ((obj*)p)->next = freeStore;   freeStore = (obj*)p;}

這樣設(shè)計好之后，任何一個class要使用它，這種寫法比較干凈，application classes不再需內(nèi)存分配糾纏不清，所有相關(guān)細(xì)節(jié)交給allocator去操心。

9.macro for static allocator4

之前的幾個版本都是在類的內(nèi)部重載了operator new()和operator delete()函數(shù)，這些版本都將分配內(nèi)存的工作放在這些函數(shù)中，但現(xiàn)在的這個版本將這些分配內(nèi)存的操作放在了allocator類中，這就漸漸接近了標(biāo)準(zhǔn)庫的方法。

從上面的代碼中可以看到，兩個類Foo和Goo中operator new()和operator delete()函數(shù)等很多部分代碼類似，于是可以使用宏來將這些高度相似的代碼提取出來，簡化類的內(nèi)部結(jié)構(gòu)，但最后達(dá)到的結(jié)果是一樣的。

//DECLARE_POOL_ALLOC -- used in class definition#define DECLARE_POOL_ALLOC() \public:\   void* operator new(size_t size) { \       return myAlloc.allocate(size); \   } \   void operator delete(void* p) { \       myAlloc.deallocate(p, 0); \   } \protected: \   static light::allocator myAlloc;
//IMPLEMENT_POOL_ALLOC -- used in class implementation#define IMPLEMENT_POOL_ALLOC(class_name) \light::allocator class_name::myAlloc;

Foo、Goo:

class Foo {DECLARE_POOL_ALLOC()public:   long L;   string str;public:   Foo(long l): L(l) {  }};
IMPLEMENT_POOL_ALLOC(Foo)
class Goo {DECLARE_POOL_ALLOC()public:   complex<double> c;   string str;public:   Goo(const complex<double> x): c(x) {  }};
IMPLEMENT_POOL_ALLOC(Goo)

10.global allocator

前面設(shè)計了版本1、2、3、 4。

版本1：最簡單，版本2：加上了embedding pointer，版本3：把內(nèi)存的動作抽取到class中，版本4：設(shè)計一個macro。

上面我們自己定義的分配器使用了一條鏈表來管理內(nèi)存的，但標(biāo)準(zhǔn)庫卻用了多條鏈表來管理，這在后續(xù)會詳細(xì)介紹:

11.new handler

當(dāng)operator new無法滿足某一內(nèi)存分配需求時，它會拋出std::bad_alloc exception。某些編譯器則返回0，你可以另編譯器那么做：new(nothrow) Foo;

在拋出異常之前，它會調(diào)用一個客戶指定的錯誤處理函數(shù)，也就是所謂的new-handler。

客戶通過調(diào)用set_new_handler來設(shè)置new-handler：

namespace std {typedef void (*new_handler)();new_handler set_new_handler(new_handler p) throw();}

set_new_handler返回之前設(shè)置的new_handler。

當(dāng)operator new無法滿足內(nèi)存申請時，它會不斷調(diào)用new-handler函數(shù)，直到找到足夠內(nèi)存。因此，一個設(shè)計良好的new-handler必須做以下事：

a：讓更多內(nèi)存可被使用，以便使operator new下一次分配內(nèi)存能夠成功。實現(xiàn)方法之一就是程序一開始就分配一大塊內(nèi)存，而后當(dāng)new-handler第一次被調(diào)用時，將它們還給程序使用；

b：安裝另一個new-handler：如果目前的new-handler無法獲得更多內(nèi)存，并且它直到另外哪個new-handler有此能力，則當(dāng)前的new-handler可以安裝那個new-handler以替換自己，下次當(dāng)operator new調(diào)用new-handler時，就是調(diào)用最新的那個。

c：卸載new-handler，一旦沒有設(shè)置new-handler，則operator new就會在無法分配內(nèi)存時拋異常；

d：拋出bad_alloc異常；

e：不返回，直接調(diào)用abort或exit。

c++ 設(shè)計是為了給我們一個機(jī)會，因為一旦內(nèi)存不足，整個軟件也不能運作，所以它借這個機(jī)會通知你，也就是通過set_new_handler調(diào)用我們的函數(shù)，由我們來決定怎么辦。

現(xiàn)在回過頭看operator new源碼：

如果malloc沒有成功，handler函數(shù)會循環(huán)調(diào)用，除非我們將handler設(shè)置為空，或者在handler中拋出異常。

operator new (std::size_t sz) _GLIBCXX_THROW (std::bad_alloc){ void *p;
 /* malloc (0) is unpredictable; avoid it. */ if (__builtin_expect (sz == 0, false))   sz = 1;
 while ((p = malloc (sz)) == 0){     new_handler handler = std::get_new_handler ();     if (! handler) //利用NULL，跑出錯誤異常     _GLIBCXX_THROW_OR_ABORT(bad_alloc());     handler ();  // 重新設(shè)定為原來的函數(shù)}
 return p;}

例子：

#include <new>#include <iostream>#include <cassert>
using namespace std;
void noMoreMemory() {   cerr<<"out of memory";   abort();}

int main() {   set_new_handler(noMoreMemory);   int *p=new int[900000000000000];   assert(p);}

輸出：

out of memory

12.=default和=delete

(=default與=delete) it is not only for constructors and assignments, but also applies to operator new/new[], operator delete/delete[] and their overloads.

解釋一下，=default和=delete不僅適用于構(gòu)造函數(shù)和賦值，還適用于operator new / new []，operator delete / delete []及其重載。

C++ 的類有四類特殊成員函數(shù)，它們分別是：默認(rèn)構(gòu)造函數(shù)、析構(gòu)函數(shù)、拷貝構(gòu)造函數(shù)以及拷貝賦值運算符。這些類的特殊成員函數(shù)負(fù)責(zé)創(chuàng)建、初始化、銷毀，或者拷貝類的對象。如果程序員沒有顯式地為一個類定義某個特殊成員函數(shù)，而又需要用到該特殊成員函數(shù)時，則編譯器會隱式的為這個類生成一個默認(rèn)的特殊成員函數(shù)。

（1）C++11 標(biāo)準(zhǔn)引入了一個新特性："=default"函數(shù)。

程序員只需在函數(shù)聲明后加上“=default;”，就可將該函數(shù)聲明為 "=default"函數(shù)，編譯器將為顯式聲明的 "=default"函數(shù)自動生成函數(shù)體。

class X {public:X() = default;}

• "=default"函數(shù)特性僅適用于類的特殊成員函數(shù)，且該特殊成員函數(shù)沒有默認(rèn)參數(shù)。

class X1{public:   int f() = default;      // err , 函數(shù) f() 非類 X 的特殊成員函數(shù)   X1(int, int) = default;  // err , 構(gòu)造函數(shù) X1(int, int) 非 X 的特殊成員函數(shù)   X1(int = 1) = default;   // err , 默認(rèn)構(gòu)造函數(shù) X1(int=1) 含有默認(rèn)參數(shù)};

• "=default"函數(shù)既可以在類體里（inline）定義，也可以在類體外（out-of-line）定義。

class X2{public:   X2() = default; //Inline defaulted 默認(rèn)構(gòu)造函數(shù)   X2(const X&);   X2& operator = (const X&);   ~X2() = default;  //Inline defaulted 析構(gòu)函數(shù)};
X2::X2(const X&) = default;  //Out-of-line defaulted 拷貝構(gòu)造函數(shù)X2& X2::operator= (const X2&) = default;   //Out-of-line defaulted 拷貝賦值操作符

（2）為了能夠讓程序員顯式的禁用某個函數(shù)，C++11 標(biāo)準(zhǔn)引入了一個新特性："=delete"函數(shù)。程序員只需在函數(shù)聲明后上“=delete;”，就可將該函數(shù)禁用。

class X3{public:   X3();   X3(const X3&) = delete;  // 聲明拷貝構(gòu)造函數(shù)為 deleted 函數(shù)   X3& operator = (const X3 &) = delete; // 聲明拷貝賦值操作符為 deleted 函數(shù)};

• "=delete"函數(shù)特性還可用于禁用類的某些轉(zhuǎn)換構(gòu)造函數(shù)，從而避免不期望的類型轉(zhuǎn)換

class X4{public:   X4(double) {}   X4(int) = delete;};

• "=delete"函數(shù)特性還可以用來禁用某些用戶自定義的類的 new 操作符，從而避免在自由存儲區(qū)創(chuàng)建類的對象

class X5{public:   void *operator new(size_t) = delete;   void *operator new[](size_t) = delete;};

回到侯老師課上，見下面兩個ppt:

首先使用了=default對operator new與operator delete，由于=defalult不能使用在這些函數(shù)上面，在侯老師代碼中，將這兩行注釋掉了，保留了=delete的代碼，所以在右側(cè)輸出，使用new沒問題，使用new[]被禁用，自然報錯，第二個是operator new與operator delete被禁用，因此new被禁用，報錯，new[]正常。

參考資料：https://www.cnblogs.com/lsgxeva/p/7787438.html