堆和棧的區別之數據結構和內存

時間 2019-12-12

標籤區別數據結構內存简体版

原文原文鏈接

數據結構的棧和堆html

首先在數據結構上要知道堆棧，儘管咱們這麼稱呼它，但實際上堆棧是兩種數據結構：堆和棧。程序員

堆和棧都是一種數據項按序排列的數據結構。算法

棧就像裝數據的桶或箱子編程

咱們先從你們比較熟悉的棧提及吧，它是一種具備後進先出性質的數據結構，也就是說後存放的先取，先存放的後取。數組

這就如同咱們要取出放在箱子裏面底下的東西（放入的比較早的物體），咱們首先要移開壓在它上面的物體（放入的比較晚的物體）。緩存

堆像一棵倒過來的樹數據結構

而堆就不一樣了，堆是一種通過排序的樹形數據結構，每一個結點都有一個值。
一般咱們所說的堆的數據結構，是指二叉堆。
堆的特色是根結點的值最小（或最大），且根結點的兩個子樹也是一個堆。

因爲堆的這個特性，經常使用來實現優先隊列，堆的存取是隨意，這就如同咱們在圖書館的書架上取書，雖然書的擺放是有順序的，可是咱們想取任意一本時沒必要像棧同樣，先取出前面全部的書，書架這種機制不一樣於箱子，咱們能夠直接取出咱們想要的書。多線程

內存分配中的棧和堆架構

先看百度百科中的內存堆棧介紹：編程語言

堆棧空間分配

棧（操做系統）：由操做系統自動分配釋放，存放函數的參數值，局部變量的值等。其操做方式相似於數據結構中的棧。

堆（操做系統）：通常由程序員分配釋放，若程序員不釋放，程序結束時可能由OS回收，分配方式卻是相似於鏈表。

堆棧緩存方式

棧使用的是一級緩存，他們一般都是被調用時處於存儲空間中，調用完畢當即釋放。

堆則是存放在二級緩存中，生命週期由虛擬機的垃圾回收算法來決定（並非一旦成爲孤兒對象就能被回收）。因此調用這些對象的速度要相對來得低一些。

下面就說說C語言程序內存分配中的堆和棧，這裏有必要把內存分配也提一下，你們不要嫌我囉嗦，通常狀況下程序存放在Rom（只讀內存，好比硬盤）或Flash中，運行時須要拷到RAM（隨機存儲器RAM）中執行，RAM會分別存儲不一樣的信息，以下圖所示：

內存中的棧區處於相對較高的地址以地址的增加方向爲上的話，棧地址是向下增加的。

棧中分配局部變量空間，堆區是向上增加的用於分配程序員申請的內存空間。另外還有靜態區是分配靜態變量，全局變量空間的；只讀區是分配常量和程序代碼空間的；以及其餘一些分區。

來看一個網上很流行的經典例子：

main.cpp

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); //堆
}

0.申請方式和回收方式不一樣

不知道你是否有點明白了。

堆和棧的第一個區別就是申請方式不一樣：棧（英文名稱是stack）是系統自動分配空間的，例如咱們定義一個 char a；系統會自動在棧上爲其開闢空間。而堆（英文名稱是heap）則是程序員根據須要本身申請的空間，例如malloc（10）；開闢十個字節的空間。

因爲棧上的空間是自動分配自動回收的，因此棧上的數據的生存週期只是在函數的運行過程當中，運行後就釋放掉，不能夠再訪問。而堆上的數據只要程序員不釋放空間，就一直能夠訪問到，不過缺點是一旦忘記釋放會形成內存泄露。還有其餘的一些區別我認爲網上的朋友總結的不錯這裏轉述一下：

1.申請後系統的響應

棧：只要棧的剩餘空間大於所申請空間，系統將爲程序提供內存，不然將報異常提示棧溢出。

堆：首先應該知道操做系統有一個記錄空閒內存地址的鏈表，當系統收到程序的申請時，會遍歷該鏈表，尋找第一個空間大於所申請空間的堆結點，而後將該結點從空閒結點鏈表中刪除，並將該結點的空間分配給程序，另外，對於大多數系統，會在這塊內存空間中的首地址處記錄本次分配的大小，這樣，代碼中的 delete語句才能正確的釋放本內存空間。另外，因爲找到的堆結點的大小不必定正好等於申請的大小，系統會自動的將多餘的那部分從新放入空閒鏈表中。

也就是說堆會在申請後還要作一些後續的工做這就會引出申請效率的問題。

2.申請效率的比較

根據第0點和第1點可知。

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

堆：是由new分配的內存，通常速度比較慢，並且容易產生內存碎片不過用起來最方便。

3.申請大小的限制

棧：在Windows下棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂的地址和棧的最大容量是系統預先規定好的，在 WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就肯定的常數），若是申請的空間超過棧的剩餘空間時，將提示overflow。所以，能從棧得到的空間較小。

堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是因爲系統是用鏈表來存儲的空閒內存地址的，天然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限於計算機系統中有效的虛擬內存。因而可知，堆得到的空間比較靈活，也比較大。

4.堆和棧中的存儲內容

因爲棧的大小有限，因此用子函數仍是有物理意義的，而不只僅是邏輯意義。

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

堆：通常是在堆的頭部用一個字節存放堆的大小。堆中的具體內容有程序員安排。

5.存取效率的比較

<span stchar s1[] = "aaaaaaaaaaaaaaa"; 
char *s2 = "bbbbbbbbbbbbbbbbb";

aaaaaaaaaaa是在運行時刻賦值的；放在棧中。
而bbbbbbbbbbb是在編譯時就肯定的；放在堆中。
可是，在之後的存取中，在棧上的數組比指針所指向的字符串(例如堆)快。

好比：

#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 clbyte ptr [ebp-0Fh]
0040106A 88 4D FC mov byte ptr [ebp-4]cl
11: a = p[1];
0040106D 8B 55 EC mov edxdword ptr [ebp-14h]
00401070 8A 42 01 mov albyte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4]al

關於堆和棧區別的比喻

堆和棧的區別能夠引用一位前輩的比喻來看出：

使用棧就象咱們去飯館裏吃飯，只管點菜（發出申請）、付錢、和吃（使用），吃飽了就走，沒必要理會切菜、洗菜等準備工做和洗碗、刷鍋等掃尾工做，他的好處是快捷，可是自由度小。

使用堆就象是本身動手作喜歡吃的菜餚，比較麻煩，可是比較符合本身的口味，並且自由度大。比喻很形象，說的很通俗易懂，不知道你是否有點收穫。

問題描述

編程語言書籍中常常解釋值類型被建立在棧上，引用類型被建立在堆上，可是並無本質上解釋這堆和棧是什麼。什麼是棧，可是它們究竟是什麼，在哪兒呢（站在實際的計算機物理內存的角度上看）？

在一般狀況下由操做系統（OS）和語言的運行時（runtime）控制嗎？
它們的做用範圍是什麼？
它們的大小由什麼決定？
哪一個更快？

答案一

棧是爲執行線程留出的內存空間。當函數被調用的時候，棧頂爲局部變量和一些 bookkeeping 數據預留塊。當函數執行完畢，塊就沒有用了，可能在下次的函數調用的時候再被使用。棧一般用後進先出（LIFO）的方式預留空間；所以最近的保留塊（reserved block）一般最早被釋放。這麼作可使跟蹤堆棧變的簡單；從棧中釋放塊（free block）只不過是指針的偏移而已。

堆（heap）是爲動態分配預留的內存空間。和棧不同，從堆上分配和從新分配塊沒有固定模式；你能夠在任什麼時候候分配和釋放它。這樣使得跟蹤哪部分堆已經被分配和被釋放變的異常複雜；有許多定製的堆分配策略用來爲不一樣的使用模式下調整堆的性能。

每個線程都有一個棧，可是每個應用程序一般都只有一個堆（儘管爲不一樣類型分配內存使用多個堆的狀況也是有的）。

直接回答你的問題： 1. 當線程建立的時候，操做系統（OS）爲每個系統級（system-level）的線程分配棧。一般狀況下，操做系統經過調用語言的運行時（runtime）去爲應用程序分配堆。 2. 棧附屬於線程，所以當線程結束時棧被回收。堆一般經過運行時在應用程序啓動時被分配，當應用程序（進程）退出時被回收。 3. 當線程被建立的時候，設置棧的大小。在應用程序啓動的時候，設置堆的大小，可是能夠在須要的時候擴展（分配器向操做系統申請更多的內存）。 4. 棧比堆要快，由於它存取模式使它能夠輕鬆的分配和從新分配內存（指針/整型只是進行簡單的遞增或者遞減運算），然而堆在分配和釋放的時候有更多的複雜的 bookkeeping 參與。另外，在棧上的每一個字節頻繁的被複用也就意味着它可能映射處處理器緩存中，因此很快（譯者注：局部性原理）。

答案二

Stack:

和堆同樣存儲在計算機 RAM 中。
在棧上建立變量的時候會擴展，而且會自動回收。
相比堆而言在棧上分配要快的多。
用數據結構中的棧實現。
存儲局部數據，返回地址，用作參數傳遞。
當用棧過多時可致使棧溢出（無窮次（大量的）的遞歸調用，或者大量的內存分配）。
在棧上的數據能夠直接訪問（不是非要使用指針訪問）。
若是你在編譯以前精確的知道你須要分配數據的大小而且不是太大的時候，可使用棧。
當你程序啓動時決定棧的容量上限。

Heap：

和棧同樣存儲在計算機RAM。
在堆上的變量必需要手動釋放，不存在做用域的問題。數據可用 delete, delete[] 或者 free 來釋放。
相比在棧上分配內存要慢。
經過程序按需分配。
大量的分配和釋放可形成內存碎片。
在 C++ 中，在堆上建立數的據使用指針訪問，用 new 或者 malloc 分配內存。
若是申請的緩衝區過大的話，可能申請失敗。
在運行期間你不知道會須要多大的數據或者你須要分配大量的內存的時候，建議你使用堆。
可能形成內存泄露。

舉例：

C++

int foo()

{

char *pBuffer; //<--nothing allocated yet (excluding the pointer itself, which is allocated here on the stack).

bool b = true; // Allocated on the stack.

if(b)

{

//Create 500 bytes on the stack

char buffer[500];

//Create 500 bytes on the heap

pBuffer = new char[500];

}//<-- buffer is deallocated here, pBuffer is not

}//<--- oops there's a memory leak, I should have called delete[] pBuffer;

答案三

堆和棧是兩種內存分配的兩個統稱。可能有不少種不一樣的實現方式，可是實現要符合幾個基本的概念:

1.對棧而言，棧中的新加數據項放在其餘數據的頂部，移除時你也只能移除最頂部的數據（不能越位獲取）。

2.對堆而言，數據項位置沒有固定的順序。你能夠以任何順序插入和刪除，由於他們沒有「頂部」數據這一律念。

上面上個圖片很好的描述了堆和棧分配內存的方式。

在一般狀況下由操做系統（OS）和語言的運行時（runtime）控制嗎？

如前所述，堆和棧是一個統稱，能夠有不少的實現方式。計算機程序一般有一個棧叫作調用棧，用來存儲當前函數調用相關的信息（好比：主調函數的地址，局部變量），由於函數調用以後須要返回給主調函數。棧經過擴展和收縮來承載信息。實際上，程序不是由運行時來控制的，它由編程語言、操做系統甚至是系統架構來決定。

堆是在任何內存中動態和隨機分配的（內存的）統稱；也就是無序的。內存一般由操做系統分配，經過應用程序調用 API 接口去實現分配。在管理動態分配內存上會有一些額外的開銷，不過這由操做系統來處理。

它們的做用範圍是什麼？

調用棧是一個低層次的概念，就程序而言，它和「做用範圍」沒什麼關係。若是你反彙編一些代碼，你就會看到指針引用堆棧部分。就高級語言而言，語言有它本身的範圍規則。一旦函數返回，函數中的局部變量會直接直接釋放。你的編程語言就是依據這個工做的。

在堆中，也很難去定義。做用範圍是由操做系統限定的，可是你的編程語言可能增長它本身的一些規則，去限定堆在應用程序中的範圍。體系架構和操做系統是使用虛擬地址的，而後由處理器翻譯到實際的物理地址中，還有頁面錯誤等等。它們記錄那個頁面屬於那個應用程序。不過你不用關心這些，由於你僅僅在你的編程語言中分配和釋放內存，和一些錯誤檢查（出現分配失敗和釋放失敗的緣由）。

它們的大小由什麼決定？

依舊，依賴於語言，編譯器，操做系統和架構。棧一般提早分配好了，由於棧必須是連續的內存塊。語言的編譯器或者操做系統決定它的大小。不要在棧上存儲大塊數據，這樣能夠保證有足夠的空間不會溢出，除非出現了無限遞歸的狀況（額，棧溢出了）或者其它不常見了編程決議。

堆是任何能夠動態分配的內存的統稱。這要看你怎麼看待它了，它的大小是變更的。在現代處理器中和操做系統的工做方式是高度抽象的，所以你在正常狀況下不須要擔憂它實際的大小，除非你必需要使用你尚未分配的內存或者已經釋放了的內存。

哪一個更快一些？

棧更快由於全部的空閒內存都是連續的，所以不須要對空閒內存塊經過列表來維護。只是一個簡單的指向當前棧頂的指針。編譯器一般用一個專門的、快速的寄存器來實現。更重要的一點事是，隨後的棧上操做一般集中在一個內存塊的附近，這樣的話有利於處理器的高速訪問（譯者注：局部性原理）。

答案四

你問題的答案是依賴於實現的，根據不一樣的編譯器和處理器架構而不一樣。下面簡單的解釋一下：

棧和堆都是用來從底層操做系統中獲取內存的。
在多線程環境下每個線程均可以有他本身徹底的獨立的棧，可是他們共享堆。並行存取被堆控制而不是棧。

堆:

堆包含一個鏈表來維護已用和空閒的內存塊。在堆上新分配（用 new 或者 malloc）內存是從空閒的內存塊中找到一些知足要求的合適塊。這個操做會更新堆中的塊鏈表。這些元信息也存儲在堆上，常常在每一個塊的頭部一個很小區域。
堆的增長新快一般從地地址向高地址擴展。所以你能夠認爲堆隨着內存分配而不斷的增長大小。若是申請的內存大小很小的話，一般從底層操做系統中獲得比申請大小要多的內存。
申請和釋放許多小的塊可能會產生以下狀態：在已用塊之間存在不少小的空閒塊。進而申請大塊內存失敗，雖然空閒塊的總和足夠，可是空閒的小塊是零散的，不能知足申請的大小，。這叫作「堆碎片」。
當旁邊有空閒塊的已用塊被釋放時，新的空閒塊可能會與相鄰的空閒塊合併爲一個大的空閒塊，這樣能夠有效的減小「堆碎片」的產生。

棧:

棧常常與 sp 寄存器（譯者注：」stack pointer」，瞭解彙編的朋友應該都知道）一塊兒工做，最初 sp 指向棧頂（棧的高地址）。
CPU 用 push 指令來將數據壓棧，用 pop 指令來彈棧。當用 push 壓棧時，sp 值減小（向低地址擴展）。當用 pop 彈棧時，sp 值增大。存儲和獲取數據都是 CPU 寄存器的值。
當函數被調用時，CPU使用特定的指令把當前的 IP （譯者注：「instruction pointer」，是一個寄存器，用來記錄 CPU 指令的位置）壓棧。即執行代碼的地址。CPU 接下來將調用函數地址賦給 IP ，進行調用。當函數返回時，舊的 IP 被彈棧，CPU 繼續去函數調用以前的代碼。
當進入函數時，sp 向下擴展，擴展到確保爲函數的局部變量留足夠大小的空間。若是函數中有一個 32-bit 的局部變量會在棧中留夠四字節的空間。當函數返回時，sp 經過返回原來的位置來釋放空間。
若是函數有參數的話，在函數調用以前，會將參數壓棧。函數中的代碼經過 sp 的當前位置來定位參數並訪問它們。
函數嵌套調用和使用魔法同樣，每一次新調用的函數都會分配函數參數，返回值地址、局部變量空間、嵌套調用的活動記錄都要被壓入棧中。函數返回時，按照正確方式的撤銷。
棧要受到內存塊的限制，不斷的函數嵌套/爲局部變量分配太多的空間，可能會致使棧溢出。當棧中的內存區域都已經被使用完以後繼續向下寫（低地址），會觸發一個 CPU 異常。這個異常接下會經過語言的運行時轉成各類類型的棧溢出異常。（譯者注：「不一樣語言的異常提示不一樣，所以經過語言運行時來轉換」我想他表達的是這個含義）

*函數的分配能夠用堆來代替棧嗎？

不能夠的，函數的活動記錄（即局部或者自動變量）被分配在棧上，這樣作不但存儲了這些變量，並且能夠用來嵌套函數的追蹤。

堆的管理依賴於運行時環境，C 使用 malloc ，C++ 使用 new ，可是不少語言有垃圾回收機制。

棧是更低層次的特性與處理器架構緊密的結合到一塊兒。當堆不夠時能夠擴展空間，這不難作到，由於能夠有庫函數能夠調用。可是，擴展棧一般來講是不可能的，由於在棧溢出的時候，執行線程就被操做系統關閉了，這已經太晚了。

參考：

http://www.cleey.com/blog/single/id/776.html

http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html

http://blog.jobbole.com/75321/

https://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap