棧（堆棧）與堆的區別

一、程式的記憶體配置

一個由C/C++編譯的程式佔用的記憶體分為以下幾個部分

1、棧區（stack）— 又名堆棧區，由編譯器自動分配釋放，存放函數傳回值、參數
以及程式的局部變數。函數內部共用（局部變數和函數傳回值以及參數的scope一
樣）。其操作方式類似於資料結構中的棧。

2、堆區（heap） — 一般由程式員分配釋放，若程式員不釋放，程式結束時可能由
OS回收(OS可能不回收，這將導致記憶體泄露，使系統可用記憶體越來越少)。注意它與
資料結構中的堆是兩回事，分配方式倒是類似於鏈表。進程內共用。記憶體可讀可寫。

3、資料區（data）—全域變數和靜態變數的儲存是放在一塊的，初始化的全域變數
和靜態變數在一塊地區， 未初始化的全域變數和未初始化的靜態變數在相鄰的另
一塊地區。 程式結束後有系統釋放。進程內共用。編譯時間確定大小，記憶體可讀可寫。

4、文字常量區—常量字串就是放在這裡的。 程式結束後由系統釋放。記憶體唯讀。

5、程式碼區—存放函數體的二進位代碼。可以在運行同一程式的多個進程間共
享。編譯時間確定，此段記憶體唯讀。

例子程式

int a = 0; //全域初始化區

char *p1; //全域未初始化區

main()

{

int b; //棧

char s[] = "abc"; //棧

char *p2; //棧

char *p3 = "123456"; //123456/0在常量區，p3在棧上。

static int c =0； //全域（靜態）初始化區

p1 = (char *)malloc(10);

p2 = (char *)malloc(20);

//分配得來得10和20位元組的地區就在堆區。

//strcpy(p1, "123456"); 123456/0放在常量區，編譯器可能會將它與p3所指向的
"123456"最佳化//成一個地方。

}

二、堆和棧的理論知識

2.1申請方式

stack: 由系統自動分配。 例如，聲明在函數中一個局部變數 int b; 系統自動在
棧中為b開闢空間.

heap: 需要程式員自己申請，並指明大小，在c中malloc函數:

如p1 = (char *)malloc(10);

在C++中用new運算子

如p2 = (char *)malloc(10);

但是注意p1、p2本身是在棧中的。

2.2 申請後系統的響應

棧：只要棧的剩餘空間大於所申請空間，系統將為程式提供記憶體，否則將報異常提
示棧溢出。

堆：首先應該知道作業系統有一個記錄空閑記憶體位址的鏈表，當系統收到程式的申
請時，

會遍曆該鏈表，尋找第一個空間大於所申請空間的堆結點，然後將該結點從空閑結
點鏈表中刪除，並將該結點的空間分配給程式，另外，對於大多數系統，會在這塊
記憶體空間中的首地址處記錄本次分配的大小，這樣，代碼中的delete語句才能正確
的釋放本記憶體空間。另外，由於找到的堆結點的大小不一定正好等於申請的大小，
系統會自動的將多餘的那部分重新放入空閑鏈表中。

2.3申請大小的限制

棧：在Windows下,棧是向低地址擴充的資料結構，是一塊連續的記憶體的地區。這句
話的意思是棧頂的地址和棧的最大容量是系統預先規定好的，在WINDOWS下，棧的
大小是2M（也有的說是1M，總之是一個編譯時間就確定的常數），如果申請的空間超
過棧的剩餘空間時，將會導致棧溢出（overflow），即棧被壓爆了，結果是災難性
的。因此，能從棧獲得的空間比較小。

堆：堆是向高地址擴充的資料結構，是不連續的記憶體地區。這是由於系統是用鏈表
來儲存的空閑記憶體位址的，自然是不連續的，而鏈表的遍曆方向是由低地址向高地
址。堆的大小受限於電腦系統中有效虛擬記憶體。由此可見，堆獲得的空間比較
靈活，也比較大。

申請的時候，棧記憶體幾乎等同與申請大小，大多數的偏差是記憶體對齊引發的幾個字
節影響。但堆記憶體也許實際上會相差很大（這主要源於記憶體管理器演算法）。常見的
記憶體管理都是按照基本記憶體塊大小來分配的。在一個基本單元是1024Byte的管理器
上，哪怕你只申請一個Byte，它也會給你1024個。頻繁的申請小的堆記憶體是不明智
的。

2.4申請效率的比較：

棧由系統自動分配，速度較快。但程式員是無法控制的。

堆是由new分配的記憶體，一般速度比較慢，而且容易產生記憶體片段,不過用起來最方便。

另外，在WINDOWS下，最好的方式是用VirtualAlloc分配記憶體，他不是在堆，也不
是在棧是直接在進程的地址空間中保留一快記憶體，雖然用起來最不方便。但是速度
快，也最靈活。

       申請棧記憶體的時間是基本確定的。核心只要棧指標的位移和對它進行初始
化（如果必要的話）。但堆中的時間是無法預測的，這是記憶體管理器的任務，跟他
的演算法和當前的堆記憶體結構有關，也許很快，也許很慢。兩者在這裡不存在可比
性，儘管大多數情況下棧記憶體的申請的確比堆記憶體要快。

2.5堆和棧中的儲存內容

棧： 在函數調用時，第一個進棧的是主函數中下一條指令（函數調用語句的下一
條可執行語句）的地址，然後是函數的各個參數，在大多數的C編譯器中，參數是
由右往左入棧的，然後是函數中的局部變數。注意靜態局部變數是不入棧的。 當
本次函數調用結束後，局部變數先出棧，然後是參數，最後棧頂指標指向最開始存
的地址，也就是主函數中的下一條指令，程式由該點繼續運行。

堆：一般是在堆的頭部用一個位元組存放堆的大小。堆中的具體內容有程式員安排。

2.6存取效率的比較

char s1[] = "aaaaaaaaaaaaaaa";

char *s2 = "bbbbbbbbbbbbbbbbb";

bbbbbbbbbbb是在運行時刻賦值的；

而aaaaaaaaaaa是在編譯時間就確定的；

但是，在以後的存取中，在棧上的數組比指標所指向的字串(例如堆)快。

這個可以用彙編中的直接存取和簡介存取來解釋。

比如：

#include

void main()

{

char a = 1;

char c[] = "1234567890";

char *p ="1234567890";

a = c[1];

a = p[1];

return;

}

對應的彙編代碼

10: a = c[1];

00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]

0040106A 88 4D FC mov byte ptr [ebp-4],cl

11: a = p[1];

0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]

00401070 8A 42 01 mov al,byte ptr [edx+1]

00401073 88 45 FC mov byte ptr [ebp-4],al

第一種在讀取時直接就把字串中的元素讀到寄存器cl中，而第二種則要先把指標
值讀到edx中，在根據edx讀取字元，顯然慢了。
2.7小結：

堆和棧的區別可以用如下的比喻來看出： 使用棧就象我們去飯館裡吃飯，只管點
菜（發出申請）、付錢、和吃（使用），吃飽了就走，不必理會切菜、洗菜等準備
工作和洗碗、刷鍋等掃尾工作，他的好處是快捷，但是自由度小。使用堆就象是自
己動手做喜歡吃的菜肴，比較麻煩，但是比較符合自己的口味，而且自由度大。

-----------------------------------------------------------------------------------

棧(stack)與堆(heap)都是Java用來在Ram中存放資料的地方。與C++不同，Java自動管理棧和堆，程式員不能直接地設定棧或堆。

Java的堆是一個運行時資料區,類的(對象從中分配空間。這些對象通過new、newarray、anewarray和multianewarray等指令建立，它們不需要程式碼來顯式的釋放。堆是由記憶體回收來負責的，堆的優勢是可以動態地分配記憶體大小，生

存期也不必事先告訴編譯器，因為它是在運行時動態分配記憶體的，Java的垃圾收集器會自動收走這些不再使用的資料。但缺點是，由於要在運行時動態分配記憶體，存取速度較慢。

棧的優勢是，存取速度比堆要快，僅次於寄存器，棧資料可以共用。但缺點是，存在棧中的資料大小與生存期必須是確定的，缺乏靈活性。棧中主要存放一些基本類型的變數（,int, short, long, byte, float, double, boolean, char

）和物件控點。

棧有一個很重要的特殊性，就是存在棧中的資料可以共用。假設我們同時定義：
int a = 3;
int b = 3；
編譯器先處理int a = 3；首先它會在棧中建立一個變數為a的引用，然後尋找棧中是否有3這個值，如果沒找到，就將3存放進來，然後將a指向3。接著處理int b = 3；在建立完b的引用變數後，因為在棧中已經有3這個值，便將b直接指

向3。這樣，就出現了a與b同時均指向3的情況。

這時，如果再令a=4；那麼編譯器會重新搜尋棧中是否有4值，如果沒有，則將4存放進來，並令a指向4；如果已經有了，則直接將a指向這個地址。因此a值的改變不會影響到b的值。

要注意這種資料的共用與兩個對象的引用同時指向一個對象的這種共用是不同的，因為這種情況a的修改並不會影響到b, 它是由編譯器完成的，它有利於節省空間的。而一個對象引用變數修改了這個對象的內部狀態，會影響到另一個對象

引用變數。

String是一個特殊的封裝類資料。可以用：
String str = new String("abc");
String str = "abc";
兩種的形式來建立，第一種是用new()來建立對象的，它會在存放於堆中。每調用一次就會建立一個新的對象。
而第二種是先在棧中建立一個對String類的對象引用變數str，然後尋找棧中有沒有存放"abc"，如果沒有，則將"abc"存放進棧，並令str指向”abc”，如果已經有”abc” 則直接令str指向“abc”。

比較類裡面的數值是否相等時，用equals()方法；當測試兩個封裝類的引用是否指向同一個對象時，用==，下面用例子說明上面的理論。
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true
可以看出str1和str2是指向同一個對象的。

String str1 =new String ("abc");
String str2 =new String ("abc");
System.out.println(str1==str2); // false
用new的方式是產生不同的對象。每一次產生一個。

因此用第一種方式建立多個”abc”字串,在記憶體中其實只存在一個對象而已. 這種寫法有利與節省記憶體空間. 同時它可以在一定程度上提高程式的運行速度，因為JVM會自動根據棧中資料的實際情況來決定是否有必要建立新對象。而對

於String str = new String("abc")；的代碼，則一概在堆中建立新對象，而不管其字串值是否相等，是否有必要建立新對象，從而加重了程式的負擔。

另一方面, 要注意: 我們在使用諸如String str = "abc"；的格式定義類時，總是想當然地認為，建立了String類的對象str。擔心陷阱！對象可能並沒有被建立！而可能只是指向一個先前已經建立的對象。只有通過new()方法才能保證

每次都建立一個新的對象。
由於String類的immutable性質，當String變數需要經常變換其值時，應該考慮使用StringBuffer類，以提高程式效率。

==================================================================================

Java把記憶體劃分成兩種：一種是棧記憶體，一種是堆記憶體

在函數中定義的一些基本類型的變數和對象的引用變數都在函數的棧記憶體中分配。
當在一段代碼塊定義一個變數時，Java就在棧中為這個變數分配記憶體空間，當超過變數的範圍後，Java會自動釋放掉為該變數所分配的記憶體空間，該記憶體空間可以立即被另作他用。
堆記憶體用來存放由new建立的對象和數組。
在堆中分配的記憶體，由Java虛擬機器的自動記憶體回收行程來管理。
在堆中產生了一個數組或對象後，還可以在棧中定義一個特殊的變數，讓棧中這個變數的取值等於數組或對象在堆記憶體中的首地址，棧中的這個變數就成了數組或對象的引用變數。
引用變數就相當於是為數組或對象起的一個名稱，以後就可以在程式中使用棧中的引用變數來訪問堆中的數組或對象