需要更多C/C學(xué)習(xí)資料的小伙伴可以點(diǎn)擊[跳轉(zhuǎn)中]。歡迎加入~1。4種內(nèi)存分配和版本

編程時(shí)，可以通過上圖中的多種方法直接或間接操作內(nèi)存。

2.1 new表達(dá)式當(dāng)使用operator new：

// 下面這個(gè)是new expression,而operator new 是函數(shù)
Complex* pc = new Complex(1,2);
上述會(huì)被編譯器轉(zhuǎn)為：

Complex *pc;
try {
// operator new 實(shí)現(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()操作分配一個(gè)目標(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)生錯(cuò)誤。

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ù)。

3.array new/array delete

3.1 array

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

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

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

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

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

其中的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分配十個(gè)內(nèi)存的int，內(nèi)存空間如上圖所示，首先內(nèi)存塊會(huì)有一個(gè)頭和尾，黃色部分為debug信息，灰色部分才是真正使用到的內(nèi)存，藍(lán)色部分的12bytes是為了讓該內(nèi)存塊以16字節(jié)對齊。在這個(gè)例子中delete pi和delete[] pi效果是一樣的，因?yàn)閕nt沒有析構(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有兩個(gè)參數(shù)，我們在下面源碼中：

看到：

_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 ,因?yàn)閜lacement new根本沒有分配memory。

5.重載

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

如果是正常情況下，調(diào)用new之后走的是第二條路線，如果在類中重載了operator new()，那么走的是第一條路線，但最后還是要調(diào)用到系統(tǒng)的::operator new()函數(shù)，這在后續(xù)的例子中會(huì)體現(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ù)，因?yàn)樗鼘θ钟杏绊?，如果使用不?dāng)將造成很大的問題。

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

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

6.pre-class allocator1

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

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

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

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

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

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

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

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

7.pre-class allocator2

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

分配與釋放同前面6。

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

union {
AirplaneRep rep; //此針對 used object
Airplane* next; //此針對 free list
};
借用一個(gè)東西的前8字節(jié)當(dāng)指針用，這樣整體上可以節(jié)省空間，這是一個(gè)很好的想法，在內(nèi)存管理中都是這么來用。

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

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

8.static allocator3

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

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

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; //小一點(diǎn)方便觀察 標(biāo)準(zhǔn)庫里面是20
};

其他類，例如：Foo和Goo，當(dāng)需要allocator這種內(nèi)存管理池，只需要寫出下面兩個(gè)函數(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)部做的動(dòng)作交給myAlloc。myAlloc是專門為Foo或者Goo之類的服務(wù)的，可以設(shè)計(jì)為靜態(tài) ：

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

這里實(shí)現(xiàn)同前面的實(shí)現(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) { //沒寫很漂亮, 不是重點(diǎn)無所謂.
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;
}
同前面實(shí)現(xiàn)：void allocator::deallocate(void* p, size_t)
{
//將 deleted object 收回插入 free list 前端
((obj*)p)->next = freeStore;
freeStore = (obj*)p;
}
這樣設(shè)計(jì)好之后，任何一個(gè)class要使用它，這種寫法比較干凈，application classes不再需內(nèi)存分配糾纏不清，所有相關(guān)細(xì)節(jié)交給allocator去操心。

9.macro for static allocator4

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

從上面的代碼中可以看到，兩個(gè)類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è)計(jì)了版本1、2、3、 4。

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

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

11.new handler

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

在拋出異常之前，它會(huì)調(diào)用一個(gè)客戶指定的錯(cuò)誤處理函數(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)存申請時(shí)，它會(huì)不斷調(diào)用new-handler函數(shù)，直到找到足夠內(nèi)存。因此，一個(gè)設(shè)計(jì)良好的new-handler必須做以下事：

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

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

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

d：拋出bad_alloc異常；

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

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

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

如果malloc沒有成功，handler函數(shù)會(huì)循環(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，跑出錯(cuò)誤異常
_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ù)以及拷貝賦值運(yùn)算符。這些類的特殊成員函數(shù)負(fù)責(zé)創(chuàng)建、初始化、銷毀，或者拷貝類的對象。如果程序員沒有顯式地為一個(gè)類定義某個(gè)特殊成員函數(shù)，而又需要用到該特殊成員函數(shù)時(shí)，則編譯器會(huì)隱式的為這個(gè)類生成一個(gè)默認(rèn)的特殊成員函數(shù)。

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

程序員只需在函數(shù)聲明后加上“=default;”，就可將該函數(shù)聲明為 "=default"函數(shù)，編譯器將為顯式聲明的 "=default"函數(shù)自動(dòng)生成函數(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）為了能夠讓程序員顯式的禁用某個(gè)函數(shù)，C++11 標(biāo)準(zhǔn)引入了一個(gè)新特性："=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 操作符，從而避免在自由存儲(chǔ)區(qū)創(chuàng)建類的對象

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