c/c++記憶體配置、指標和數組對比

 轉自：http://qiuyili68.blog.163.com/blog/static/67531803201111195115375/?fromdm&fromSearch&isFromSearchEngine=yes

 

記憶體配置方式

       在C++中，記憶體分成5個區，他們分別是堆、棧、自由儲存區、全域/靜態儲存區和常量儲存區。
       棧，在執行函數時，函數內局部變數的儲存單元都可以在棧上建立，函數執行結束時這些儲存單元自動被釋放。棧記憶體配置運算內建於處理器的指令集中，效率很高，但是分配的記憶體容量有限。

　　堆，就是那些由new分配的記憶體塊，他們的釋放編譯器不去管，由我們的應用程式去控制，一般一個new就要對應一個delete。如果程式員沒有釋放掉，那麼在程式結束後，作業系統會自動回收。

　　自由儲存區，就是那些由malloc等分配的記憶體塊，他和堆是十分相似的，不過它是用free來結束自己的生命的。

　　全域/靜態儲存區，全域變數和靜態變數被分配到同一塊記憶體中，在以前的C語言中，全域變數又分為初始化的和未初始化的，在C++裡面沒有這個區分了，他們共同佔用同一塊記憶體區。

　　常量儲存區，這是一塊比較特殊的儲存區，他們裡面存放的是常量，不允許修改。

明確區分堆和棧

       舉一個例子：

       void f() { int* p=new int[5]; }

　　這條短短的一句話就包含了堆與棧，看到new，我們首先就應該想到，我們分配了一塊堆記憶體，那麼指標p呢？他分配的是一塊棧記憶體，所以這句話的意思就是：在棧記憶體中存放了一個指向一塊堆記憶體的指標p。在程式會先確定在堆中分配記憶體的大小，然後調用operator new分配記憶體，然後返回這塊記憶體的首地址，放入棧中，他在VC6下的彙編代碼如下：

       00401028 push 14h

       0040102A call operator new (00401060)

       0040102F add esp,4

       00401032 mov dword ptr [ebp-8],eax

       00401035 mov eax,dword ptr [ebp-8]

       00401038 mov dword ptr [ebp-4],eax

堆和棧區別

　　主要的區別由以下幾點：

　　1、管理方式不同；

　　2、空間大小不同；

　　3、能否產生片段不同；

　　4、生長方向不同；

　　5、分配方式不同；

　　6、分配效率不同；

　　管理方式：對於棧來講，是由編譯器自動管理，無需我們手工控制；對於堆來說，釋放工作由程式員控制，容易產生memory leak。

　　空間大小：一般來講在32位系統下，堆記憶體可以達到4G的空間，從這個角度來看堆記憶體幾乎是沒有什麼限制的。但是對於棧來講，一般都是有一定的空間大小的，例如，在VC6下面，預設的棧空間大小是1M（好像是，記不清楚了）。當然，我們可以修改：

　　開啟工程，依次操作菜單如下：Project->Setting->Link，在Category 中選中Output，然後在Reserve中設定堆棧的最大值和commit。

　　注意：reserve最小值為4Byte；commit是保留在虛擬記憶體的頁檔案裡面，它設定的較大會使棧開闢較大的值，可能增加記憶體的開銷和啟動時間。

　　片段問題：對於堆來講，頻繁的new/delete勢必會造成記憶體空間的不連續，從而造成大量的片段，使程式效率降低。對於棧來講，則不會存在這個問題，因為棧是先進後出的隊列，他們是如此的一一對應，以至於永遠都不可能有一個記憶體塊從棧中間彈出，在他彈出之前，在他上面的後進的棧內容已經被彈出，詳細的可以參考資料結構。

　　生長方向：對於堆來講，生長方向是向上的，也就是向著記憶體位址增加的方向；對於棧來講，它的生長方向是向下的，是向著記憶體位址減小的方向增長。

　　分配方式：堆都是動態分配的，沒有靜態分配的堆。棧有2種分配方式：靜態分配和動態分配。靜態分配是編譯器完成的，比如局部變數的分配。動態分配由alloca函數進行分配，但是棧的動態分配和堆是不同的，他的動態分配是由編譯器進行釋放，無需我們手工實現。

　　分配效率：棧是機器系統提供的資料結構，電腦會在底層對棧提供支援：分配專門的寄存器存放棧的地址，壓棧出棧都有專門的指令執行，這就決定了棧的效率比較高。堆則是C/C++函數庫提供的，它的機制是很複雜的，例如為了分配一塊記憶體，庫函數會按照一定的演算法（具體的演算法可以參考資料結構/作業系統）在堆記憶體中搜尋可用的足夠大小的空間，如果沒有足夠大小的空間（可能是由於記憶體片段太多），就有可能調用系統功能去增加程式資料區段的記憶體空間，這樣就有機會分到足夠大小的記憶體，然後進行返回。顯然，堆的效率比棧要低得多。

　　從這裡我們可以看到，堆和棧相比，由於大量new/delete的使用，容易造成大量的記憶體片段；由於沒有專門的系統支援，效率很低；由於可能引發使用者態和核心態的切換，記憶體的申請，代價變得更加昂貴。所以棧在程式中是應用最廣泛的，就算是函數的調用也利用棧去完成，函數調用過程中的參數，返回地址，EBP和局部變數都採用棧的方式存放。所以，我們應當盡量用棧，而不是用堆。

　　雖然棧有如此眾多的好處，但是由於和堆相比不是那麼靈活，有時候分配大量的記憶體空間，還是用堆好一些。

       無論是堆還是棧，都要防止越界現象的發生（除非你是故意使其越界），因為越界的結果要麼是程式崩潰，要麼是摧毀程式的堆、棧結構，產生以想不到的結果,就算是在你的程式運行過程中，沒有發生上面的問題，你還是要小心，說不定什麼時候就崩掉，那時候debug可是相當困難的：）

常見的記憶體錯誤及其對策

      發生記憶體錯誤是件非常麻煩的事情。編譯器不能自動探索這些錯誤，通常是在程式運行時才能捕捉到。而這些錯誤大多沒有明顯的癥狀，時隱時現，增加了改錯的難度。有時使用者怒氣沖沖地把你找來，程式卻沒有發生任何問題，你一走，錯誤又發作了。 常見的記憶體錯誤及其對策如下：
     * 記憶體配置未成功，卻使用了它

編程新手常犯這種錯誤，因為他們沒有意識到記憶體配置會不成功。常用解決辦法是，在使用記憶體之前檢查指標是否為NULL。如果指標p是函數的參數，那麼在函數的入口處用assert(p!=NULL)進行檢查。如果是用malloc或new來申請記憶體，應該用if(p==NULL) 或if(p!=NULL)進行防錯處理。

* 記憶體配置雖然成功，但是尚未初始化就引用它

犯這種錯誤主要有兩個起因：一是沒有初始化的觀念；二是誤以為記憶體的預設初值全為零，導致引用初值錯誤（例如數組）。記憶體的預設初值究竟是什麼並沒有統一的標準，儘管有些時候為零值，我們寧可信其無不可信其有。所以無論用何種方式建立數組，都別忘了賦初值，即便是賦零值也不可省略，不要嫌麻煩。

* 記憶體配置成功並且已經初始化，但操作越過了記憶體的邊界

例如在使用數組時經常發生下標“多1”或者“少1”的操作。特別是在for迴圈語句中，迴圈次數很容易搞錯，導致數組操作越界。

* 忘記了釋放記憶體，造成記憶體泄露

含有這種錯誤的函數每被調用一次就丟失一塊記憶體。剛開始時系統的記憶體充足，你看不到錯誤。終有一次程式突然死掉，系統出現提示：記憶體耗盡。

動態記憶體的申請與釋放必須配對，程式中malloc與free的使用次數一定要相同，否則肯定有錯誤（new/delete同理）。

* 釋放了記憶體卻繼續使用它

有三種情況：

（1）程式中的對象調用關係過於複雜，實在難以搞清楚某個對象究竟是否已經釋放了記憶體，此時應該重新設計資料結構，從根本上解決對象管理的混亂局面。

（2）函數的return語句寫錯了，注意不要返回指向“棧記憶體”的“指標”或者“引用”，因為該記憶體在函數體結束時被自動銷毀。

（3）使用free或delete釋放了記憶體後，沒有將指標設定為NULL。導致產生“野指標”。

【規則1】用malloc或new申請記憶體之後，應該立即檢查指標值是否為NULL。防止使用指標值為NULL的記憶體。

【規則2】不要忘記為數組和動態記憶體賦初值。防止將未被初始化的記憶體作為右值使用。

【規則3】避免數組或指標的下標越界，特別要當心發生“多1”或者“少1”操作。

【規則4】動態記憶體的申請與釋放必須配對，防止記憶體流失。

【規則5】用free或delete釋放了記憶體之後，立即將指標設定為NULL，防止產生“野指標”。

 

 

指標與數組的對比

C++/C程式中，指標和數組在不少地方可以相互替換著用，讓人產生一種錯覺，以為兩者是等價的。

數組要麼在靜態儲存區被建立（如全域數組），要麼在棧上被建立。數組名對應著（而不是指向）一塊記憶體，其地址與容量在生命期內保持不變，只有數組的內容可以改變。

指標可以隨時指向任意類型的記憶體塊，它的特徵是“可變”，所以我們常用指標來操作動態記憶體。指標遠比數組靈活，但也更危險。

下面以字串為例比較指標與數組的特性。

1 修改內容

下例中，字元數組a的容量是6個字元，其內容為hello。a的內容可以改變，如a[0]= 'x'。指標p指向常量字串"world"（位於靜態儲存區，內容為world），常量字串的內容是不可以被修改的。從文法上看，編譯器並不覺得語句 p[0]= 'x'有什麼不妥，但是該語句企圖修改常量字串的內容而導致運行錯誤。

#include<iostream.h>

void main()
   {
    char a[] = "hello";
    a[0] = 'x';
    cout << a << endl;
    char *p = "world"; // 注意p指向常量字串
    p[0] = 'x'; // 編譯器不能發現該錯誤
    cout << p << endl;
    }

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)
…

 3 計算記憶體容量

用運算子sizeof可以計算出數組的容量（位元組數）。下例(a)中，sizeof(a)的值是12（注意別忘了' '）。指標p指向a，但是 sizeof(p)的值卻是4。這是因為sizeof(p)得到的是一個指標變數的位元組數，相當於sizeof(char*)，而不是p所指的記憶體容量。 C++/C語言沒有辦法知道指標所指的記憶體容量，除非在申請記憶體時記住它。注意當數組作為函數的參數進行傳遞時，該數組自動退化為同類型的指標。下例(b)中，不論數組a的容量是多少，sizeof(a)始終等於sizeof(char *)。

樣本(a)
char a[] = "hello world";
char *p = a;
cout<< sizeof(a) << endl; // 12位元組
cout<< sizeof(p) << endl; // 4位元組
樣本(b)
void Func(char a[100])
  {
　cout<< sizeof(a) << endl; // 4位元組而不是100位元組
}

       4 指標參數傳遞記憶體

       如果函數的參數是一個指標，不要指望用該指標去申請動態記憶體。如下樣本中，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"); // 運行錯誤

}

       毛病出在函數GetMemory中。編譯器總是要為函數的每個參數製作臨時副本，指標參數p的副本是 _p，編譯器使 _p = p。如果函數體內的程式修改了_p的內容，就導致參數p的內容作相應的修改。這就是指標可以用作輸出參數的原因。在本例中，_p申請了新的記憶體，只是把_p所指的記憶體位址改變了，但是p絲毫未變。所以函數GetMemory並不能輸出任何東西。事實上，每執行一次GetMemory就會泄露一塊記憶體，因為沒有用free釋放記憶體。

       如果非得要用指標參數去申請記憶體，那麼應該改用“指向指標的指標”，見樣本：

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);

}
      由於“指向指標的指標”這個概念不容易理解，我們可以用函數傳回值來傳遞動態記憶體。這種方法更加簡單，見樣本：

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);

}
 用函數傳回值來傳遞動態記憶體這種方法雖然好用，但是常常有人把return語句用錯了。這裡強調不要用return語句返回指向“棧記憶體”的指標，因為該記憶體在函數結束時自動消亡，見樣本：

char *GetString(void)

{

　char p[] = "hello world";

　return p; // 編譯器將提出警告

}

void Test4(void)

{

　char *str = NULL;

　str = GetString(); // str 的內容是垃圾

　cout<< str << endl;

}

用調試器逐步跟蹤Test4，發現執行str = GetString語句後str不再是NULL指標，但是str的內容不是“hello world”而是垃圾。

如果把上述樣本改寫成如下樣本，會怎麼樣？

char *GetString2(void)

{

　char *p = "hello world";

　return p;

}

void Test5(void)

{

　char *str = NULL;

　str = GetString2();

　cout<< str << endl;

}

函數Test5運行雖然不會出錯，但是函數GetString2的設計概念卻是錯誤的。因為GetString2內的“hello world”是常量字串，位於靜態儲存區，它在程式生命期內恒定不變。無論什麼時候調用GetString2，它返回的始終是同一個“唯讀”的記憶體塊。

        5 杜絕“野指標”
　　“野指標”不是NULL指標，是指向“垃圾”記憶體的指標。人們一般不會錯用NULL指標，因為用if語句很容易判斷。但是“野指標”是很危險的，if語句對它不起作用。 “野指標”的成因主要有兩種：

（1）指標變數沒有被初始化。任何指標變數剛被建立時不會自動成為NULL指標，它的預設值是隨機的，它會亂指一氣。所以，指標變數在建立的同時應當被初始化，要麼將指標設定為NULL，要麼讓它指向合法的記憶體。例如

char *p = NULL;

char *str = (char *) malloc(100);
 

（2）指標p被free或者delete之後，沒有置為NULL，讓人誤以為p是個合法的指標。

（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就成了“野指標”。但奇怪的是我運行這個程式時居然沒有出錯，這可能與編譯器有關。

 

轉自：http://qiuyili68.blog.163.com/blog/static/67531803201111195115375/?fromdm&fromSearch&isFromSearchEngine=yes