C++中內存的動態(tài)分配與管理永遠是一個讓C++開發(fā)者頭痛的問題，本文通過對C++中內存的動態(tài)分配釋放的基本原理的介紹，讓讀者朋友能對C++中的內存的動態(tài)分配與釋放有較為深入的理解，從而更好駕馭C++程序。
1. 函數(Function)
(1) operator new function
1
2
|
void * ::operator new(size_t); //Global
void * class-name::operator new(size_t); //Class |
上面是C++中operator new function的原型，一個是全局類型的，一個的類成員類型的。全局類型的operator new函數在下面兩種情況下被調用：一種是在分配C++內建（built-in）類型的動態(tài)內存時，一種是在分配用戶沒有自己定義operator new成員函數的用戶自定義類型的動態(tài)內存時。 如果用戶在自己定義的類型中，定義了operator new函數，那么用戶在用new申請該類型的動態(tài)內存時, 便會調用該類型的成員函數operator new, 而不是全局的operator new。
另外，我們注意到，上面的原型中函數的返回值為void *類型, 第一個參數為size_t類型，這個是C++編譯器要求的，如果要自己重載operator new函數，返回值必須為void* 類型，第一個參數必須為size_t類型，否則，編譯器會返回如下錯誤信息：
1
|
error: ‘operator new’ takes type ‘size_t’ (‘unsigned int’) as first parameter |
這里需要注意的一點是，我們可以利用operator new function可以重載的特點，可以通過參數傳入一些額外的信息，來調試程序，檢測內存泄露等。比如，我們可以像下面這樣重載，傳入調用處的行號，函數名，這樣就可以跟蹤內存的分配使用情況：
1
2
3
4
5
|
void * operator new(size_t unSize, int nLine, const char * pFunc)
{
prinft("Line: %d, Func: %s, allocate %u byte(s)\n", nLine, pFunc, unSize);
return malloc(unSize);
} |
(2) operator delete function
1
2
|
void operator delete( void * );
void operator delete( void *, size_t ); |
上面是operator delete function的原型。operator delete function也有全局的和類成員的兩種。這里需要注意，一個類只能有一個operator delete function做為其成員函數，而且必須為上面兩種中的其中一種，沒有其它的形式。如果一個類實現了自己的operator delete function成員函數，那么在釋放該類型的內存時，編譯器便會調用成員operator delete function, 而不是全局的。
上面的兩種原型，第一種，在調用的時候，編譯器會把要釋放的內存的首地址傳入，第二種，在調用的時候，編譯器會把要釋放的內存的首地址和大小都傳入。因此，可以利用這一特性，如果我們在基類中實現第二種形式的operator delete function的成員函數，那么便可以用之來釋放子類類型的內存（具體參考最后面的例子）。
2. 運算符(Operator)
(1) new operator
1
2
|
[::] new [placement] new-type-name [new-initializer]
[::] new [placement] ( type-name ) [new-initializer] |
注：上面的’[]‘表示在其中的部分是optional（可選的）
上面是new operator的原型。在C++中，動態(tài)內存的分配,通常都是調用new operator來完成的，利用new operator來分配動態(tài)內存，編譯器要做下面兩項工作：
- a. 調用operator new function分配內存（allocate the memory）
- b. 調用構造函數（call the constructor）來進行初始化
下面來說一說new operator的原型中各部分到底是干什么的：
placement: 如果你重載了operator new function, placement可以用來傳遞額外的參數
type-name: 指定要分配的內存的類型，可以是內建(built-in)類型，也可以是用戶自定義類型
new-initializer: 指定對分配后內存的初始化的參數，也就的構造函數的參數 。這里需要注意一點，在分配一個對象的數組類型的內存時，不能夠指定初始化參數；換言之，要想分配一個對象的數組類型的內存，該對象必須有缺省構造函數
(2) delete opeartor
1
2
|
[::] delete cast-expression
[::] delete [ ] cast-expression |
上面是delete operator的原型，第一種用來釋放普通的對象(包括內建類型）類型的內存，第二種用來釋放對象的數組類型的內存。在C++中，用new operator分配的動態(tài)內存，必須調用delete operator來釋放，通常用delete operator釋放內存編譯器要做下面兩項工作：
- a. 調用對象析構函數來析構對象
- b. 調用operator delete function來釋放內存(deallocate the memory)
3. 關于new/delete使用過程中一些需要注意的點
(1)如何區(qū)別operator new/delete function 與 new/delete operator ?
通過上面的講述，不難看出，我們分配/釋放動態(tài)內存，調用的是new/delete operator, 而在調用new/delete的過程中，編譯器會自動調用operator new/delete function來完成實際的內存分配/釋放的工作
(2) 用delete operator去釋放一塊不是由new operator釋放的內存，結果是不可預料的，因此，切記，operator new與operator delete一定要配對使用，這是寫好程序的基礎
(3) new operator調用失敗會拋出std::bad_alloc異常，前提是你沒有自己重載對應的operator new function；delete operator失敗，常見的原因是多次delete同一塊內存
(4) 如果一塊內存被delete后，再對它解引用(Dereference)，結果也是不可預測的，很可能導致程序崩潰
(5) delete一個空(NULL)指針是安全的，沒有任何害處的
(6) 類成員類型的operator new/delete函數必須為靜態(tài)(static)函數，因此它們不能為虛函數(virtual function)，也遵守public, protected, private的訪問權限控制
4. 關于上面所講的內容的一些例子：
程序：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
#include <stdio .h>
#include <stdlib .h>
void * operator new(size_t unSize)
{
printf("operator new called\n");
return malloc(unSize);
}
void * operator new(size_t unSize, int nLine, const char * pFunc)
{
printf("operator new called, line: %d, func: %s\n",
nLine, pFunc);
return malloc(unSize);
}
void operator delete(void * pMem)
{
printf("delete1\n");
free(pMem);
}
class A
{
public:
A(int a = 0) :
_a(a)
{
printf("constructor called\n");
}
{
printf("~A()\n");
}
static void operator delete(void * pMem, size_t unSize)
{
printf("delete2: %u\n", unSize);
free(pMem);
}
private:
int _a;
};
class B: public A
{
public:
~B()
{
printf("~B()\n");
}
int _b;
int _bb;
};
int main()
{
A * pA = new A(10);
printf("#######\n");
A * pB = new (__LINE__, __func__) B();
printf("#######\n");
A * szA = new A[10];
printf("#######\n");
delete pA;
printf("#######\n");
delete pB;
printf("#######\n");
delete [] szA;
printf("#######\n");
char * pC = NULL;
delete pC;
}
</stdlib></stdio> |
運行結果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
wuzesheng@wuzesheng-ubuntu:~/Program$ ./a.out
operator new called
constructor called
#######
operator new called, line: 68, func: main
constructor called
#######
operator new called
constructor called
constructor called
constructor called
constructor called
constructor called
constructor called
constructor called
constructor called
constructor called
constructor called
#######
~A()
delete2: 8
#######
~B()
~A()
delete2: 16
#######
~A()
~A()
~A()
~A()
~A()
~A()
~A()
~A()
~A()
~A()
delete1
#######
delete1 |
上面的程序很簡單，我在這里不做過多的解釋，感興趣的朋友可以自己分析一下。
通過我上面的講解，相信大多數朋友應該對C++中內存的動態(tài)分配與釋放有了較為深入的理解。后續(xù)我還有可能寫一些關于C++中內存管理的文章，只有把本文所講的內容與后續(xù)的內存管理的一些常見的方法結合起來，我們才寫出更加健壯的C++程序。歡迎讀者朋友留言一起交流！