第7 章 內存管理
歡迎進入內存這片雷區。偉大的Bill Gates 曾經失言：
640K ought to be enough for everybody
— Bill Gates 1981
程序員們經常編寫內存管理程序，往往提心吊膽。如果不想觸雷，唯一的解決辦法
就是發現所有潛伏的地雷并且排除它們，躲是躲不了的。本章的內容比一般教科書的要
深入得多，讀者需細心閱讀，做到真正地通曉內存管理。
7.1 內存分配方式
內存分配方式有三種：
（1） 從靜態存儲區域分配。內存在程序編譯的時候就已經分配好，這塊內存在程序的
整個運行期間都存在。例如全局變量，static 變量。
（2） 在棧上創建。在執行函數時，函數內局部變量的存儲單元都可以在棧上創建，函
數執行結束時這些存儲單元自動被釋放。棧內存分配運算內置于處理器的指令集
中，效率很高，但是分配的內存容量有限。
（3） 從堆上分配，亦稱動態內存分配。程序在運行的時候用malloc 或new 申請任意多
少的內存，程序員自己負責在何時用free 或delete 釋放內存。動態內存的生存期
由我們決定，使用非常靈活，但問題也最多。
7.2 常見的內存錯誤及其對策
發生內存錯誤是件非常麻煩的事情。編譯器不能自動發現這些錯誤，通常是在程序
運行時才能捕捉到。而這些錯誤大多沒有明顯的癥狀，時隱時現，增加了改錯的難度。
有時用戶怒氣沖沖地把你找來，程序卻沒有發生任何問題，你一走，錯誤又發作了。
常見的內存錯誤及其對策如下：
.. 內存分配未成功，卻使用了它。
編程新手常犯這種錯誤，因為他們沒有意識到內存分配會不成功。常用解決辦法是，
在使用內存之前檢查指針是否為NULL。如果指針p 是函數的參數，那么在函數的入口
處用assert(p!=NULL)進行檢查。如果是用malloc 或new 來申請內存，應該用if(p==NULL)
或if(p!=NULL)進行防錯處理。
.. 內存分配雖然成功，但是尚未初始化就引用它。
犯這種錯誤主要有兩個起因：一是沒有初始化的觀念；二是誤以為內存的缺省初值
全為零，導致引用初值錯誤（例如數組）。
內存的缺省初值究竟是什么并沒有統一的標準，盡管有些時候為零值，我們寧可信
高質量C++/C 編程指南，v 1.0
2001 Page 45 of 101
其無不可信其有。所以無論用何種方式創建數組，都別忘了賦初值，即便是賦零值也不
可省略，不要嫌麻煩。
.. 內存分配成功并且已經初始化，但操作越過了內存的邊界。
例如在使用數組時經常發生下標“多1”或者“少1”的操作。特別是在for 循環語
句中，循環次數很容易搞錯，導致數組操作越界。
.. 忘記了釋放內存，造成內存泄露。
含有這種錯誤的函數每被調用一次就丟失一塊內存。剛開始時系統的內存充足，你
看不到錯誤。終有一次程序突然死掉，系統出現提示：內存耗盡。
動態內存的申請與釋放必須配對，程序中malloc 與free 的使用次數一定要相同，否
則肯定有錯誤（new/delete 同理）。
.. 釋放了內存卻繼續使用它。
有三種情況：
（1）程序中的對象調用關系過于復雜，實在難以搞清楚某個對象究竟是否已經釋放了內
存，此時應該重新設計數據結構，從根本上解決對象管理的混亂局面。
（2）函數的return 語句寫錯了，注意不要返回指向“棧內存”的“指針”或者“引用”，
因為該內存在函數體結束時被自動銷毀。
（3）使用free 或delete 釋放了內存后，沒有將指針設置為NULL。導致產生“野指針”。
.. 【規則7-2-1】用malloc 或new 申請內存之后，應該立即檢查指針值是否為NULL。
防止使用指針值為NULL 的內存。
.. 【規則7-2-2】不要忘記為數組和動態內存賦初值。防止將未被初始化的內存作為右
值使用。
.. 【規則7-2-3】避免數組或指針的下標越界，特別要當心發生“多1”或者“少1”
操作。
.. 【規則7-2-4】動態內存的申請與釋放必須配對，防止內存泄漏。
.. 【規則7-2-5】用free 或delete 釋放了內存之后，立即將指針設置為NULL，防止產
生“野指針”。
7.3 指針與數組的對比
C++/C 程序中，指針和數組在不少地方可以相互替換著用，讓人產生一種錯覺，以
為兩者是等價的。
數組要么在靜態存儲區被創建（如全局數組），要么在棧上被創建。數組名對應著（而
不是指向）一塊內存，其地址與容量在生命期內保持不變，只有數組的內容可以改變。
指針可以隨時指向任意類型的內存塊，它的特征是“可變”，所以我們常用指針來操
作動態內存。指針遠比數組靈活，但也更危險。
高質量C++/C 編程指南，v 1.0
2001 Page 46 of 101
下面以字符串為例比較指針與數組的特性。
7.3.1 修改內容
示例7-3-1 中，字符數組a 的容量是6 個字符，其內容為hello\0。a 的內容可以改變，
如a[0]= ‘X’。指針p 指向常量字符串“world”（位于靜態存儲區，內容為world\0），常
量字符串的內容是不可以被修改的。從語法上看，編譯器并不覺得語句p[0]= ‘X’有什么
不妥，但是該語句企圖修改常量字符串的內容而導致運行錯誤。
char a[] = “hello”;
a[0] = ‘X’;
cout << a << endl;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘X’; // 編譯器不能發現該錯誤
cout << p << endl;
示例7-3-1 修改數組和指針的內容
7.3.2 內容復制與比較
不能對數組名進行直接復制與比較。示例7-3-2 中，若想把數組a 的內容復制給數
組b，不能用語句 b = a ，否則將產生編譯錯誤。應該用標準庫函數strcpy 進行復制。
同理，比較b 和a 的內容是否相同，不能用if(b==a) 來判斷，應該用標準庫函數strcmp
進行比較。
語句p = a 并不能把a 的內容復制指針p，而是把a 的地址賦給了p。要想復制a
的內容，可以先用庫函數malloc 為p 申請一塊容量為strlen(a)+1 個字符的內存，再用
strcpy 進行字符串復制。同理，語句if(p==a) 比較的不是內容而是地址，應該用庫函
數strcmp 來比較。
// 數組…
char a[] = "hello";
char b[10];
strcpy(b, a); // 不能用 b = a;
if(strcmp(b, a) == 0) // 不能用 if (b == a)
…
// 指針…
int len = strlen(a);
char *p = (char *)malloc(sizeof(char)*(len+1));
strcpy(p,a); // 不要用 p = a;
if(strcmp(p, a) == 0) // 不要用 if (p == a)
…
示例7-3-2 數組和指針的內容復制與比較
高質量C++/C 編程指南，v 1.0
2001 Page 47 of 101
7.3.3 計算內存容量
用運算符sizeof 可以計算出數組的容量（字節數）。示例7-3-3（a）中，sizeof(a)
的值是12（注意別忘了’\0’）。指針p 指向a，但是sizeof(p)的值卻是4。這是因為
sizeof(p)得到的是一個指針變量的字節數，相當于sizeof(char*)，而不是p 所指的內
存容量。C++/C 語言沒有辦法知道指針所指的內存容量，除非在申請內存時記住它。
注意當數組作為函數的參數進行傳遞時，該數組自動退化為同類型的指針。示例
7-3-3（b）中，不論數組a 的容量是多少，sizeof(a)始終等于sizeof(char *)。
char a[] = "hello world";
char *p = a;
cout<< sizeof(a) << endl; // 12 字節
cout<< sizeof(p) << endl; // 4 字節
示例7-3-3（a） 計算數組和指針的內存容量
void Func(char a[100])
{
cout<< sizeof(a) << endl; // 4 字節而不是100 字節
}
示例7-3-3（b） 數組退化為指針
7.4 指針參數是如何傳遞內存的？
如果函數的參數是一個指針，不要指望用該指針去申請動態內存。示例7-4-1 中，
Test 函數的語句GetMemory(str, 200)并沒有使str 獲得期望的內存，str 依舊是NULL，
為什么？
void GetMemory(char *p, int num)
{
p = (char *)malloc(sizeof(char) * num);
}
void Test(void)
{
char *str = NULL;
GetMemory(str, 100); // str 仍然為 NULL
strcpy(str, "hello"); // 運行錯誤
}
示例7-4-1 試圖用指針參數申請動態內存
高質量C++/C 編程指南，v 1.0
2001 Page 48 of 101
毛病出在函數GetMemory 中。編譯器總是要為函數的每個參數制作臨時副本，指針
參數p 的副本是 _p，編譯器使 _p = p。如果函數體內的程序修改了_p 的內容，就導致
參數p 的內容作相應的修改。這就是指針可以用作輸出參數的原因。在本例中，_p 申請
了新的內存，只是把_p 所指的內存地址改變了，但是p 絲毫未變。所以函數GetMemory
并不能輸出任何東西。事實上，每執行一次GetMemory 就會泄露一塊內存，因為沒有用
free 釋放內存。
如果非得要用指針參數去申請內存，那么應該改用“指向指針的指針”，見示例7-4-2。
void GetMemory2(char **p, int num)
{
*p = (char *)malloc(sizeof(char) * num);
}
void Test2(void)
{
char *str = NULL;
GetMemory2(&str, 100); // 注意參數是 &str，而不是str
strcpy(str, "hello");
cout<< str << endl;
free(str);
}
示例7-4-2 用指向指針的指針申請動態內存
由于“指向指針的指針”這個概念不容易理解，我們可以用函數返回值來傳遞動態
內存。這種方法更加簡單，見示例7-4-3。
char *GetMemory3(int num)
{
char *p = (char *)malloc(sizeof(char) * num);
return p;
}
void Test3(void)
{
char *str = NULL;
str = GetMemory3(100);
strcpy(str, "hello");
cout<< str << endl;
free(str);
}
示例7-4-3 用函數返回值來傳遞動態內存
高質量C++/C 編程指南，v 1.0
2001 Page 49 of 101
用函數返回值來傳遞動態內存這種方法雖然好用，但是常常有人把return 語句用錯
了。這里強調不要用return 語句返回指向“棧內存”的指針，因為該內存在函數結束時
自動消亡，見示例7-4-4。
char *GetString(void)
{
char p[] = "hello world";
return p; // 編譯器將提出警告
}
void Test4(void)
{
char *str = NULL;
str = GetString(); // str 的內容是垃圾
cout<< str << endl;
}
示例7-4-4 return 語句返回指向“棧內存”的指針
用調試器逐步跟蹤Test4，發現執行str = GetString 語句后str 不再是NULL 指針，
但是str 的內容不是“hello world”而是垃圾。
如果把示例7-4-4 改寫成示例7-4-5，會怎么樣？
char *GetString2(void)
{
char *p = "hello world";
return p;
}
void Test5(void)
{
char *str = NULL;
str = GetString2();
cout<< str << endl;
}
示例7-4-5 return 語句返回常量字符串
函數Test5 運行雖然不會出錯，但是函數GetString2 的設計概念卻是錯誤的。因為
GetString2 內的“hello world”是常量字符串，位于靜態存儲區，它在程序生命期內
恒定不變。無論什么時候調用GetString2，它返回的始終是同一個“只讀”的內存塊。
高質量C++/C 編程指南，v 1.0
2001 Page 50 of 101
7.5 free 和delete 把指針怎么啦？
別看free 和delete 的名字惡狠狠的（尤其是delete），它們只是把指針所指的內存給
釋放掉，但并沒有把指針本身干掉。
用調試器跟蹤示例7-5，發現指針p 被free 以后其地址仍然不變（非NULL），只是
該地址對應的內存是垃圾，p 成了“野指針”。如果此時不把p 設置為NULL，會讓人誤
以為p 是個合法的指針。
如果程序比較長，我們有時記不住p 所指的內存是否已經被釋放，在繼續使用p 之
前，通常會用語句if (p != NULL)進行防錯處理。很遺憾，此時if 語句起不到防錯作用，
因為即便p 不是NULL 指針，它也不指向合法的內存塊。
char *p = (char *) malloc(100);
strcpy(p, “hello”);
free(p); // p 所指的內存被釋放，但是p 所指的地址仍然不變
…
if(p != NULL) // 沒有起到防錯作用
{
strcpy(p, “world”); // 出錯
}
示例7-5 p 成為野指針
7.6 動態內存會被自動釋放嗎？
函數體內的局部變量在函數結束時自動消亡。很多人誤以為示例7-6 是正確的。理
由是p 是局部的指針變量，它消亡的時候會讓它所指的動態內存一起完蛋。這是錯覺！
void Func(void)
{
char *p = (char *) malloc(100); // 動態內存會自動釋放嗎？
}
示例7-6 試圖讓動態內存自動釋放
我們發現指針有一些“似是而非”的特征：
（1）指針消亡了，并不表示它所指的內存會被自動釋放。
（2）內存被釋放了，并不表示指針會消亡或者成了NULL 指針。
這表明釋放內存并不是一件可以草率對待的事。也許有人不服氣，一定要找出可以
草率行事的理由：
如果程序終止了運行，一切指針都會消亡，動態內存會被操作系統回收。既然如此，
高質量C++/C 編程指南，v 1.0
2001 Page 51 of 101
在程序臨終前，就可以不必釋放內存、不必將指針設置為NULL 了。終于可以偷懶而不會
發生錯誤了吧？
想得美。如果別人把那段程序取出來用到其它地方怎么辦？
7.7 杜絕“野指針”
“野指針”不是NULL 指針，是指向“垃圾”內存的指針。人們一般不會錯用NULL
指針，因為用if 語句很容易判斷。但是“野指針”是很危險的，if 語句對它不起作用。
“野指針”的成因主要有兩種：
（1）指針變量沒有被初始化。任何指針變量剛被創建時不會自動成為NULL 指針，它
的缺省值是隨機的，它會亂指一氣。所以，指針變量在創建的同時應當被初始化，要么
將指針設置為NULL，要么讓它指向合法的內存。例如
char *p = NULL;
char *str = (char *) malloc(100);
（2）指針p 被free 或者delete 之后，沒有置為NULL，讓人誤以為p 是個合法的指針。
參見7.5 節。
（3）指針操作超越了變量的作用范圍。這種情況讓人防不勝防，示例程序如下：
class A
{
public:
void Func(void){ cout << “Func of class A” << endl; }
};
void Test(void)
{
A *p;
{
A a;
p = &a; // 注意 a 的生命期
}
p->Func(); // p 是“野指針”
}
函數Test 在執行語句p->Func()時，對象a 已經消失，而p 是指向a 的，所以p 就
成了“野指針”。但奇怪的是我運行這個程序時居然沒有出錯，這可能與編譯器有關。
高質量C++/C 編程指南，v 1.0
2001 Page 52 of 101
7.8 有了malloc/free 為什么還要new/delete ？
malloc 與free 是C++/C 語言的標準庫函數，new/delete 是C++的運算符。它們都可
用于申請動態內存和釋放內存。
對于非內部數據類型的對象而言，光用maloc/free 無法滿足動態對象的要求。對象
在創建的同時要自動執行構造函數， 對象在消亡之前要自動執行析構函數。由于
malloc/free 是庫函數而不是運算符，不在編譯器控制權限之內，不能夠把執行構造函數
和析構函數的任務強加于malloc/free。
因此C++語言需要一個能完成動態內存分配和初始化工作的運算符new，以及一個
能完成清理與釋放內存工作的運算符delete。注意new/delete 不是庫函數。
我們先看一看malloc/free 和new/delete 如何實現對象的動態內存管理，見示例7-8。
class Obj
{
public :
Obj(void){ cout << “Initialization” << endl; }
~Obj(void){ cout << “Destroy” << endl; }
void Initialize(void){ cout << “Initialization” << endl; }
void Destroy(void){ cout << “Destroy” << endl; }
};
void UseMallocFree(void)
{
Obj *a = (obj *)malloc(sizeof(obj)); // 申請動態內存
a->Initialize(); // 初始化
//…
a->Destroy(); // 清除工作
free(a); // 釋放內存
}
void UseNewDelete(void)
{
Obj *a = new Obj; // 申請動態內存并且初始化
//…
delete a; // 清除并且釋放內存
}
示例7-8 用malloc/free 和new/delete 如何實現對象的動態內存管理
類Obj 的函數Initialize 模擬了構造函數的功能，函數Destroy 模擬了析構函數的功
能。函數UseMallocFree 中，由于malloc/free 不能執行構造函數與析構函數，必須調用
成員函數Initialize 和Destroy 來完成初始化與清除工作。函數UseNewDelete 則簡單得多。
高質量C++/C 編程指南，v 1.0
2001 Page 53 of 101
所以我們不要企圖用malloc/free 來完成動態對象的內存管理，應該用new/delete。
由于內部數據類型的“對象”沒有構造與析構的過程，對它們而言malloc/free 和new/delete
是等價的。
既然new/delete 的功能完全覆蓋了malloc/free，為什么C++不把malloc/free 淘
汰出局呢？這是因為C++程序經常要調用C 函數，而C 程序只能用malloc/free 管理動
態內存。
如果用free 釋放“new 創建的動態對象”，那么該對象因無法執行析構函數而可能
導致程序出錯。如果用delete 釋放“malloc 申請的動態內存”，理論上講程序不會出錯，
但是該程序的可讀性很差。所以new/delete 必須配對使用，malloc/free 也一樣。
7.9 內存耗盡怎么辦？
如果在申請動態內存時找不到足夠大的內存塊，malloc 和new 將返回NULL 指針，
宣告內存申請失敗。通常有三種方式處理“內存耗盡”問題。
（1）判斷指針是否為NULL，如果是則馬上用return 語句終止本函數。例如：
void Func(void)
{
A *a = new A;
if(a == NULL)
{
return;
}
…
}
（2）判斷指針是否為NULL，如果是則馬上用exit(1)終止整個程序的運行。例如：
void Func(void)
{
A *a = new A;
if(a == NULL)
{
cout << “Memory Exhausted” << endl;
exit(1);
}
…
}
（3）為new 和malloc 設置異常處理函數。例如Visual C++可以用_set_new_hander 函數
為new 設置用戶自己定義的異常處理函數，也可以讓malloc 享用與new 相同的異常處
高質量C++/C 編程指南，v 1.0
2001 Page 54 of 101
理函數。詳細內容請參考C++使用手冊。
上述（1）（2）方式使用最普遍。如果一個函數內有多處需要申請動態內存，那么方
式（1）就顯得力不從心（釋放內存很麻煩），應該用方式（2）來處理。
很多人不忍心用exit(1)，問：“不編寫出錯處理程序，讓操作系統自己解決行不行？”
不行。如果發生“內存耗盡”這樣的事情，一般說來應用程序已經無藥可救。如果
不用exit(1) 把壞程序殺死，它可能會害死操作系統。道理如同：如果不把歹徒擊斃，歹
徒在老死之前會犯下更多的罪。
有一個很重要的現象要告訴大家。對于32 位以上的應用程序而言，無論怎樣使用
malloc 與new，幾乎不可能導致“內存耗盡”。我在Windows 98 下用Visual C++編寫了
測試程序，見示例7-9。這個程序會無休止地運行下去，根本不會終止。因為32 位操作
系統支持“虛存”，內存用完了，自動用硬盤空間頂替。我只聽到硬盤嘎吱嘎吱地響，
Window 98 已經累得對鍵盤、鼠標毫無反應。
我可以得出這么一個結論：對于32 位以上的應用程序，“內存耗盡”錯誤處理程序
毫無用處。這下可把Unix 和Windows 程序員們樂壞了：反正錯誤處理程序不起作用，
我就不寫了，省了很多麻煩。
我不想誤導讀者，必須強調：不加錯誤處理將導致程序的質量很差，千萬不可因小
失大。
void main(void)
{
float *p = NULL;
while(TRUE)
{
p = new float[1000000];
cout << “eat memory” << endl;
if(p==NULL)
exit(1);
}
}
示例7-9 試圖耗盡操作系統的內存
7.10 malloc/free 的使用要點
函數malloc 的原型如下：
void * malloc(size_t size);
用malloc 申請一塊長度為length 的整數類型的內存，程序如下：
int *p = (int *) malloc(sizeof(int) * length);
高質量C++/C 編程指南，v 1.0
2001 Page 55 of 101
我們應當把注意力集中在兩個要素上：“類型轉換”和“sizeof”。
.. malloc 返回值的類型是void *，所以在調用malloc 時要顯式地進行類型轉換，將
void * 轉換成所需要的指針類型。
.. malloc 函數本身并不識別要申請的內存是什么類型，它只關心內存的總字節數。我
們通常記不住int, float 等數據類型的變量的確切字節數。例如int 變量在16 位系統
下是2 個字節，在32 位下是4 個字節；而float 變量在16 位系統下是4 個字節，在
32 位下也是4 個字節。最好用以下程序作一次測試：
cout << sizeof(char) << endl;
cout << sizeof(int) << endl;
cout << sizeof(unsigned int) << endl;
cout << sizeof(long) << endl;
cout << sizeof(unsigned long) << endl;
cout << sizeof(float) << endl;
cout << sizeof(double) << endl;
cout << sizeof(void *) << endl;
在malloc 的“()”中使用sizeof 運算符是良好的風格，但要當心有時我們會昏了
頭，寫出 p = malloc(sizeof(p))這樣的程序來。
.. 函數free 的原型如下：
void free( void * memblock );
為什么free 函數不象malloc 函數那樣復雜呢？這是因為指針p 的類型以及它所指
的內存的容量事先都是知道的，語句free(p)能正確地釋放內存。如果p 是NULL 指針，
那么free 對p 無論操作多少次都不會出問題。如果p 不是NULL 指針，那么free 對p
連續操作兩次就會導致程序運行錯誤。
7.11 new/delete 的使用要點
運算符new 使用起來要比函數malloc 簡單得多，例如：
int *p1 = (int *)malloc(sizeof(int) * length);
int *p2 = new int[length];
這是因為new 內置了sizeof、類型轉換和類型安全檢查功能。對于非內部數據類型
的對象而言，new 在創建動態對象的同時完成了初始化工作。如果對象有多個構造函數，
那么new 的語句也可以有多種形式。例如
class Obj
{
public :
Obj(void); // 無參數的構造函數
Obj(int x); // 帶一個參數的構造函數
高質量C++/C 編程指南，v 1.0
2001 Page 56 of 101
…
}
void Test(void)
{
Obj *a = new Obj;
Obj *b = new Obj(1); // 初值為1
…
delete a;
delete b;
}
如果用new 創建對象數組，那么只能使用對象的無參數構造函數。例如
Obj *objects = new Obj[100]; // 創建100 個動態對象
不能寫成
Obj *objects = new Obj[100](1);// 創建100 個動態對象的同時賦初值1
在用delete 釋放對象數組時，留意不要丟了符號‘[]’。例如
delete []objects; // 正確的用法
delete objects; // 錯誤的用法
后者相當于delete objects[0]，漏掉了另外99 個對象。
7.12 一些心得體會
我認識不少技術不錯的C++/C 程序員，很少有人能拍拍胸脯說通曉指針與內存管理
（包括我自己）。我最初學習C 語言時特別怕指針，導致我開發第一個應用軟件（約1
萬行C 代碼）時沒有使用一個指針，全用數組來頂替指針，實在蠢笨得過分。躲避指針
不是辦法，后來我改寫了這個軟件，代碼量縮小到原先的一半。
我的經驗教訓是：
（1）越是怕指針，就越要使用指針。不會正確使用指針，肯定算不上是合格的程序員。
（2）必須養成“使用調試器逐步跟蹤程序”的習慣，只有這樣才能發現問題的本質。