C ?內(nèi)存管理（一）
[導(dǎo)讀]C內(nèi)存管理（一）導(dǎo)語c內(nèi)存管理學(xué)習(xí)自侯捷。下面是本次對C內(nèi)存管理一些筆記。1.四種內(nèi)存分配與釋放在編程時(shí)可以通過上圖的幾種方法直接或間接地操作內(nèi)存。下面將介紹四種C內(nèi)存操作方法：對于GNUC：四種分配與釋放方式如下：//C函數(shù)void*p1=malloc(512);*(int*)...
C 內(nèi)存管理（一）
導(dǎo)語
c 內(nèi)存管理學(xué)習(xí)自侯捷。下面是本次對C 內(nèi)存管理一些筆記。1.四種內(nèi)存分配與釋放
在編程時(shí)可以通過上圖的幾種方法直接或間接地操作內(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ù) 實(shí)際上等價(jià)于上述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等價(jià)于之前的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);#endif2.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 實(shí)現(xiàn)自 new_op.cc void* mem = operator new(sizeof(Complex)); //allocate 分配內(nèi)存 pc = static_cast(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()具體實(shí)現(xiàn)源代碼見：https://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/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()具體實(shí)現(xiàn)源代碼見：https://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/del_op.cc3.array new/array delete
3.1 array
上圖主要展示的是關(guān)于array new內(nèi)存分配的大致情況。當(dāng)new一個數(shù)組對象時(shí)（例如 new Complex[3]），編譯器將分配一塊內(nèi)存，這塊內(nèi)存首部是關(guān)于對象內(nèi)存分配的一些標(biāo)記，然后下面會分配三個連續(xù)的對象內(nèi)存，在使用delete釋放內(nèi)存時(shí)需要使用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效果是一樣的，因?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(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++-v3/libsupc++/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 ,因?yàn)閜lacement 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ù)，因?yàn)樗鼘θ钟杏绊懀绻褂貌划?dāng)將造成很大的問題。如果是在類中重載operator new()方法，那么該方法有N多種形式，但必須保證函數(shù)參數(shù)列表第一個參數(shù)是size_t類型變量；對于operator delete()，第一個參數(shù)必須是void* 類型，第二個size_t是可選項(xiàng)，可以去掉。對于operator new[]和operator delete[]函數(shù)的重載，和前面類似。
6.pre-class allocator1
前面把基本元素的重載元素學(xué)完了，例如：new、operator new、array new等等。萬事俱備，現(xiàn)在可以開始一個class進(jìn)行內(nèi)存管理。對于malloc來說，大家都有一個誤解，以為它很慢，其實(shí)它不慢，后面會講到。無論如何，減少malloc的調(diào)用次數(shù)，總是很好的，所以設(shè)計(jì)class者，可以先挖一塊，只使用一次malloc，使用者使用，就只需要調(diào)用一次malloc，這樣就是一個小型的內(nèi)存管理。除了降低malloc次數(shù)之外，還需要降低cookie用量。前面提到一次malloc需要一組(兩個)cookie，總共8字節(jié)。所以，如果一次要1000個大小，這1000個切下來，都是不帶cookie，只有1000個一整包上下帶cookie。所以內(nèi)存池的設(shè)計(jì)就是一整塊，一個池塘。這一大塊設(shè)計(jì)不但要提升速度，而且要降低浪費(fèi)率。所以內(nèi)存管理目標(biāo)就是，一個是速度，一個是空間。每次挖一大塊，需要指針把他們穿起來，如下圖右邊鏈表結(jié)構(gòu)，基于這個考量，下面例子中設(shè)計(jì)了next指針。此時(shí)碰到了一個困惑：多設(shè)計(jì)了一個指針，去除了cookie，卻膨脹率100%(int i 占4字節(jié)，指針也是4字節(jié))。使用者使用new的時(shí)候，就會被接管到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è)計(jì)，這里帶來了一個觀念：嵌入式指針，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ù)難點(diǎn)非常高，后面談！雖然沒有還給操作系統(tǒng)，但不能說它內(nèi)存泄露，因?yàn)檫@些都在它的"手上"。8.static allocator3
不要把內(nèi)存分配與回收寫在各個class中，而要把它們集中在一個allocator中！在前面設(shè)計(jì)中，每次都需要重載相應(yīng)的函數(shù)，內(nèi)部處理一些邏輯，重復(fù)代碼量多，我們可以將這些包裝起來，使它容易被重復(fù)使用。以下展示一個作法：每個allocator object都是個分配器，在allocator設(shè)計(jì)了allocate與deallocate兩個函數(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)存管理池，只需要寫出下面兩個函數(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è)計(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ì)好之后，任何一個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è)計(jì)了版本1、2、3、 4。版本1：最簡單，版本2：加上了embedding pointer，版本3：把內(nèi)存的動作抽取到class中，版本4：設(shè)計(jì)一個macro。上面我們自己定義的分配器使用了一條鏈表來管理內(nèi)存的，但標(biāo)準(zhǔn)庫卻用了多條鏈表來管理，這在后續(xù)會詳細(xì)介紹:11.new handler
當(dāng)operator new無法滿足某一內(nèi)存分配需求時(shí)，它會拋出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)存申請時(shí)，它會不斷調(diào)用new-handler函數(shù)，直到找到足夠內(nèi)存。因此，一個設(shè)計(jì)良好的new-handler必須做以下事：a：讓更多內(nèi)存可被使用，以便使operator new下一次分配內(nèi)存能夠成功。實(shí)現(xiàn)方法之一就是程序一開始就分配一大塊內(nèi)存，而后當(dāng)new-handler第一次被調(diào)用時(shí)，將它們還給程序使用；b：安裝另一個new-handler：如果目前的new-handler無法獲得更多內(nèi)存，并且它直到另外哪個new-handler有此能力，則當(dāng)前的new-handler可以安裝那個new-handler以替換自己，下次當(dāng)operator new調(diào)用new-handler時(shí)，就是調(diào)用最新的那個。c：卸載new-handler，一旦沒有設(shè)置new-handler，則operator new就會在無法分配內(nèi)存時(shí)拋異常；d：拋出bad_alloc異常；e：不返回，直接調(diào)用abort或exit。c 設(shè)計(jì)是為了給我們一個機(jī)會，因?yàn)橐坏﹥?nèi)存不足，整個軟件也不能運(yùn)作，所以它借這個機(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 #include #include
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 memory12.=default和=delete
(=default與=delete) it is not only for constructors and assignments, but also applies tooperator 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)建、初始化、銷毀，或者拷貝類的對象。如果程序員沒有顯式地為一個類定義某個特殊成員函數(shù)，而又需要用到該特殊成員函數(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 
下載文檔
