C語言 -- 存儲區域

C程序 -- 存儲區域[一]
由C語言代碼（文本文件）造成可執行程序（二進制文件），須要通過編譯-彙編-鏈接三個階段。編譯過程把C語言文本文件生成彙編程序，彙編過程把彙編程序造成二進制機器代碼，鏈接過程則將各個源文件生成的二進制機器代碼文件組合成一個文件。C語言編寫的程序通過編譯-鏈接後，將造成一個統一文件，它由幾個部分組成。在程序運行時又會產生其餘幾個部分，各個部分表明了不一樣的存儲區域：
1.代碼段（Code或Text）
代碼段由程序中執行的機器代碼組成。在C語言中，程序語句進行編譯後，造成機器代碼。在執行程序的過程當中，CPU的程序計數器指向代碼段的每一條機器代碼，並由處理器依次運行。
2.只讀數據段（RO data）
只讀數據段是程序使用的一些不會被更改的數據，使用這些數據的方式相似查表式的操做，因爲這些變量不須要更改，所以只須要放置在只讀存儲器中便可。
3.已初始化讀寫數據段（RW data）
已初始化數據是在程序中聲明，而且具備初值的變量，這些變量須要佔用存儲器的空間，在程序執行時它們須要位於可讀寫的內存區域內，並具備初值，以供程序運行時讀寫。
4.未初始化讀寫數據段（BSS）
未初始化數據是在程序中聲明，可是沒有初始化的變量，這些變量在程序運行以前不須要佔用存儲器的空間。
5.堆（heap）
堆內存只在程序運行時出現，通常由程序員分配和釋放。在具備操做系統的狀況下，若是程序沒有釋放，操做系統可能在程序（例如一個進程）結束後回收內存。
6.棧（stack）
棧內存只在程序運行時出現，在函數內部使用的變量、函數的參數以及返回值將使用棧空間，棧空間由編譯器自動分配和釋放。
示例：

　 int a = 0;                         //全局初始化區。  已初始化讀寫數據段（RW data）
    static int b=20;                //全局初始化區。  已初始化讀寫數據段（RW data）
    char *p1;                        //全局未初始化區，未初始化數據段（BSS）
    const int A = 10;              //只讀數據段（RO data）
    void main（ void ）
    {
    int b;                          //棧
    char s[] = "abc" ;              //棧
    char *p2;                       //棧
    static int c = 0;               //全局（靜態）初始化區 .data段
    char *p3 = "123456" ;           //123456\0在常量區，p3在棧上。
    p1 = （ char *） malloc （10）；//分配得來的10和20個字節的區域就在堆區
    p2 = （ char *） malloc （20）；
    strcpy （p1, "123456" ）；      //123456\0 在常量區，編譯器可能會將它與p3所指向的"123456"優化成一個地方
    }

　　代碼段、只讀數據段、讀寫數據段、未初始化數據段屬於靜態區域，而堆和棧屬於動態區域。代碼段、只讀數據段和讀寫數據段將在連接以後產生，未初始化數據段將在程序
初始化的時候開闢，而堆和棧將在程序的運行中分配和釋放。C語言程序分爲映像和運行時兩種狀態。在編譯-鏈接後造成的映像中，將只包含代碼段（Text）、只讀數據段（RO Data）和讀寫數據段（RW Data）。在程序運行以前，將動態生成未初始化數據段（BSS），在程序的運行時還將動態造成堆（Heap）區域和棧（Stack）區域。通常來講，在靜態的映像文件中，各個部分稱之爲節（Section），而在運行時的各個部分稱之爲段（Segment）。若是不詳細區分，能夠統稱爲段。

變量使用注意：
1.函數體中定義的變量一般是在棧上，不須要在程序中進行管理，由編繹器處理。
2.用malloc,calloc,realloc等分配內存的函數所分配的內存空間在堆上，程序必須保證在使用free釋放，不然會發生內存泄漏。
3.全部函數體外定義的是全局變量，加了static後的變量無論是在函數內部或外部都放在全局區。
4.使用const定義的變量將放於程序的只讀數據區。

棧空間主要用於如下3種數據的存儲：
1.函數內部的動態變量
2.函數的參數
3.函數的返回值

棧空間是動態開闢與回收的。在函數調用過程當中，若是函數調用的層次比較多，所須要的棧空間也逐漸加大，對於參數的傳遞和返回值，若是使用較大的結構體，在使用的棧空間也會比較大。

---------------------------------------------------------------------------------------------------------------
C程序 -- 存儲區域[二]
1. 棧 －－  由編譯器自動分配釋放
2. 堆 －－  一般由程序員分配釋放，若程序員不釋放，程序結束時可能由OS回收
3. 全局區（靜態區）－－ 全局變量和靜態變量的存儲是放在一塊的，初始化的全局變量和靜態變量在一塊區域，未初始化的全局變量和未初始化的靜態變量在相鄰的另外一塊區域。 程序結束釋放。
4. 常量區－－ 專門放常量的地方，程序結束釋放。

在函數體中定義的變量一般是在棧上，用malloc, calloc, realloc等分配內存的函數分配獲得的就是在堆上。在全部函數體外定義的是全局量，加了static修飾符後無論在哪裏都存放在全局區（靜態區）,在全部函數體外定義的static變量表示在該文件中有效，不能extern到別的文件用，在函數體內定義的static表示只在該函數體內有效。另外，函數中的"helloworld"這樣的字符串存放在常量區。
好比：
代碼:
int a = 0; //全局初始化區
char *p1; //全局未初始化區
main()
{
int b; //棧
char s[] = "abc"; //棧
char *p2; //棧
char *p3 = "123456"; //123456在常量區，p3在棧上。
static int c = 0； //全局（靜態）初始化區
p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
//分配得來得10和20字節的區域就在堆區。
strcpy(p1, "123456");
//123456放在常量區，編譯器可能會將它與p3所指向的"123456"優化成一塊。
還有就是函數調用時會在棧上有一系列的保留現場及傳遞參數的操做。
棧的空間大小有限定，vc的缺省是2M。棧不夠用的狀況通常是程序中分配了大量數組和遞歸函數層次太深。有一點必須知道，當一個函數調用完返回後它會釋放該函數中全部的棧空間。棧是由編譯器自動管理的。
堆是動態分配內存的，而且你能夠分配使用很大的內存。可是用很差會產生內存泄漏。而且頻繁地malloc和free會產生內存碎片（有點相似磁盤碎片），由於c分配動態內存時是尋找匹配的內存的。而用棧則不會產生碎片。
在棧上存取數據比經過指針在堆上存取數據快些。
通常你們說的堆棧和棧是同樣的，就是棧(stack)，而說堆時纔是堆heap. 棧是先入後出的，通常是由高地址向低地址生長。堆(heap)和棧(stack)是C/C++編程不可避免會碰到的兩個基本概念。首先，這兩個概念均可以在講數據結構的書中找到，他們都是基本的數據結構，雖然棧更爲簡單一些。
在具體的C/C++編程框架中，這兩個概念並非並行的。對底層機器代碼的研究能夠揭示，棧是機器系統提供的數據結構，而堆則是C/C++函數庫提供的。
具體地說，現代計算機(串行執行機制)，都直接在代碼底層支持棧的數據結構。這體如今，有專門的寄存器指向棧所在的地址，有專門的機器指令完成數據入棧出棧的操做。
機制的特色是效率高，支持的數據有限，通常是整數，指針，浮點數等系統直接支持的數據類型，並不直接支持其餘的數據結構。由於棧的這種特色，對棧的使用在程序中是很是頻繁的。對子程序的調用就是直接利用棧完成的。機器的call指令裏隱含了把返回地址推入棧，而後跳轉至子程序地址的操做，而子程序中的ret指令則隱含從堆棧中彈出返回地址並跳轉之的操做。C/C++中的自動變量是直接利用棧的例子，這也就是爲何當函數返回時，該函數的自動變量自動失效的緣由。和棧不一樣，堆的數據結構並非由系統(不管是機器系統仍是操做系統)支持的，而是由函數庫提供的。基本的malloc/realloc/free函數維護了一套內部的堆數據結構。當程序使用這些函數去得到新的內存空間時，這套函數首先試圖從內部堆中尋找可用的內存空間，若是沒有可使用的內存空間，則試圖利用系統調用來動態增長程序數據段的內存大小，新分配獲得的空間首先被組織進內部堆中去，而後再以適當的形式返回給調用者。當程序釋放分配的內存空間時，這片內存空間被返回內部堆結構中，可能會被適當的處理(好比和其餘空閒空間合併成更大的空閒空間)，以更適合下一次內存分配申請。這套複雜的分配機制實際上至關於一個內存分配的緩衝池(Cache)，使用這套機制有以下若干緣由：

1. 系統調用可能不支持任意大小的內存分配。有些系統的系統調用只支持固定大小及其倍數的內存請求(按頁分配)；這樣的話對於大量的小內存分類來講會形成浪費。
2. 系統調用申請內存多是代價昂貴的。系統調用可能涉及用戶態和核心態的轉換。
3. 沒有管理的內存分配在大量複雜內存的分配釋放操做下很容易形成內存碎片。

堆和棧的對比
從以上知識可知，棧是系統提供的功能，特色是快速高效，缺點是有限制，數據不靈活；而堆是函數庫提供的功能，特色是靈活方便，數據適應面普遍，可是效率有必定下降。棧是系統數據結構，對於進程/線程是惟一的；堆是函數庫內部數據結構，不必定惟一。不一樣堆分配的內存沒法互相操做。
棧空間分靜態分配和動態分配兩種。靜態分配是編譯器完成的，好比自動變量(auto)的分配。動態分配由malloca函數完成。棧的動態分配無需釋放(是自動的)，也就沒有釋放函數。爲可移植的程序起見，棧的動態分配操做是不被鼓勵的！堆空間的分配老是動態的，雖然程序結束時全部的數據空間都會被釋放回系統，可是精確的申請內存/釋放內存匹配是良
好程序的基本要素。

C程序 -- 存儲區域[三]

一個由c/C++編譯的程序佔用的內存分爲如下幾個部分

一、棧區（stack）— 程序運行時由編譯器自動分配，存放函數的參數值，局部變量的值等。其操做方式相似於數據結構中的棧。程

序結束時由編譯器自動釋放。

二、堆區（heap） — 在內存開闢另外一塊存儲區域。通常由程序員分配釋放， 若程序員不釋放，程序結束時可能由OS回收 。注意它

與數據結構中的堆是兩回事，分配方式卻是相似於鏈表，呵呵。

三、全局區（靜態區）（static）—編譯器編譯時即分配內存。全局變量和靜態變量的存儲是放在一塊的，初始化的全局變量和靜態

變量在一塊區域， 未初始化的全局變量和未初始化的靜態變量在相鄰的另外一塊區域。 - 程序結束後由系統釋放

四、文字常量區 —常量字符串就是放在這裏的。 程序結束後由系統釋放

五、程序代碼區—存放函數體的二進制代碼。

例子程序

這是一個前輩寫的，很是詳細

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

//分配得來得10和20字節的區域就在堆區。

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

}

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

C語言程序的內存分配方式

1.內存分配方式
　　內存分配方式有三種：
　　[1]從靜態存儲區域分配。內存在程序編譯的時候就已經分配好，這塊內存在程序的整個運行期間都存在。例如全局變量，

static變量。
　　[2]在棧上建立。在執行函數時，函數內局部變量的存儲單元均可以在棧上建立，函數執行結束時這些存儲單元自動被釋放。棧

內存分配運算內置於處理器的指令集中，效率很高，可是分配的內存容量有限。
　　[3]從堆上分配，亦稱動態內存分配。程序在運行的時候用malloc或new申請任意多少的內存，程序員本身負責在什麼時候用free或

delete釋放內存。動態內存的生存期由程序員決定，使用很是靈活，但若是在堆上分配了空間，就有責任回收它，不然運行的程序會

出現內存泄漏，頻繁地分配和釋放不一樣大小的堆空間將會產生堆內碎塊。
2.程序的內存空間
　　一個程序將操做系統分配給其運行的內存塊分爲4個區域，以下圖所示。
　　一個由C/C++編譯的程序佔用的內存分爲如下幾個部分,
　　一、棧區（stack）—　 由編譯器自動分配釋放 ，存放爲運行函數而分配的局部變量、函數參數、返回數據、返回地址等。其操

做方式相似於數據結構中的棧。
　　二、堆區（heap） —　 通常由程序員分配釋放， 若程序員不釋放，程序結束時可能由OS回收 。分配方式相似於鏈表。
　　三、全局區（靜態區）（static）—存放全局變量、靜態數據、常量。程序結束後由系統釋放。
　　四、文字常量區 —常量字符串就是放在這裏的。 程序結束後由系統釋放。
　　五、程序代碼區—存放函數體（類成員函數和全局函數）的二進制代碼。
　　下面給出例子程序，
　　int a = 0; //全局初始化區
　　char *p1; //全局未初始化區
　　int main() {
　　int b; //棧
　　char s[] = "abc"; //棧
　　char *p2; //棧
　　char *p3 = "123456"; //123456在常量區，p3在棧上。
　　static int c =0;//全局（靜態）初始化區
　　p1 = new char[10];
　　p2 = new char[20];
　　//分配得來得和字節的區域就在堆區。
　　strcpy(p1, "123456"); //123456放在常量區，編譯器可能會將它與p3所指向的"123456"優化成一個地方。
　　}
3．堆與棧的比較
　　3.1申請方式
　　stack: 由系統自動分配。 例如，聲明在函數中一個局部變量 int b; 系統自動在棧中爲b開闢空間。
　　heap: 須要程序員本身申請，並指明大小，在C中malloc函數，C++中是new運算符。
　　如p1 = (char *)malloc(10); p1 = new char[10];
　　如p2 = (char *)malloc(10); p2 = new char[20];
　　可是注意p一、p2自己是在棧中的。
　　3.2申請後系統的響應
　　棧：只要棧的剩餘空間大於所申請空間，系統將爲程序提供內存，不然將報異常提示棧溢出。
　　堆：首先應該知道操做系統有一個記錄空閒內存地址的鏈表，當系統收到程序的申請時，會遍歷該鏈表，尋找第一個空間大於所

申請空間的堆結點，而後將該結點從空閒結點鏈表中刪除，並將該結點的空間分配給程序。
　　對於大多數系統，會在這塊內存空間中的首地址處記錄本次分配的大小，這樣，代碼中的delete語句才能正確的釋放本內存空間

。
　　因爲找到的堆結點的大小不必定正好等於申請的大小，系統會自動的將多餘的那部分從新放入空閒鏈表中。
　　3.3申請大小的限制
　　棧：在Windows下,棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂的地址和棧的最大容量是系統

預先規定好的，在 WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就肯定的常數），若是申請的空間超過棧的剩餘空

間時，將提示overflow。因 此，能從棧得到的空間較小。
　　堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是因爲系統是用鏈表來存儲的空閒內存地址的，天然是不連續的，

而鏈表的遍歷方向是由低地址向高地址。堆的大小受限於計算機系統中有效的虛擬內存。因而可知，堆得到的空間比較靈活，也比較

大。
　　3.4申請效率的比較
　　棧由系統自動分配，速度較快。但程序員是沒法控制的。
　　堆是由new分配的內存，通常速度比較慢，並且容易產生內存碎片,不過用起來最方便。
　　另外，在WINDOWS下，最好的方式是用VirtualAlloc分配內存，他不是在堆，也不是棧，而是直接在進程的地址空間中保留一快

內存，雖然用起來最不方便。可是速度快，也最靈活。
　　3.5堆和棧中的存儲內容
　　棧：在函數調用時，第一個進棧的是主函數中後的下一條指令（函數調用語句的下一條可執行語句）的地址，而後是函數的各個

參數，在大多數的C編譯器中，參數是由右往左入棧的，而後是函數中的局部變量。注意靜態變量是不入棧的。
　　當本次函數調用結束後，局部變量先出棧，而後是參數，最後棧頂指針指向最開始存的地址，也就是主函數中的下一條指令，程

序由該點繼續運行。
　　堆：通常是在堆的頭部用一個字節存放堆的大小。堆中的具體內容有程序員安排。
　　3.6存取效率的比較
　　char s1[] = "a";
　　char *s2 = "b";
　　a是在運行時刻賦值的；而b是在編譯時就肯定的；可是，在之後的存取中，在棧上的數組比指針所指向的字符串(例如堆)快。

好比：
　　int　main(){
　　char a = 1;
　　char c[] = "1234567890";
　　char *p ="1234567890";
　　a = c[1];
　　a = p[1];
　　return 0;
　　}
　　對應的彙編代碼
　　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讀取字符，顯然慢了

。

3.7小結
　　堆和棧的主要區別由如下幾點：
　　一、管理方式不一樣；
　　二、空間大小不一樣；
　　三、可否產生碎片不一樣；
　　四、生長方向不一樣；
　　五、分配方式不一樣；
　　六、分配效率不一樣；
　　管理方式：對於棧來說，是由編譯器自動管理，無需咱們手工控制；對於堆來講，釋放工做由程序員控制，容易產生memory

leak。
　　空間大小：通常來說在32位系統下，堆內存能夠達到4G的空間，從這個角度來看堆內存幾乎是沒有什麼限制的。可是對於棧來說

，通常都是有必定的空間大小的，例如，在VC6下面，默認的棧空間大小是1M。固然，這個值能夠修改。
　　碎片問題：對於堆來說，頻繁的new/delete勢必會形成內存空間的不連續，從而形成大量的碎片，使程序效率下降。對於棧來說

，則不會存在這個問題，由於棧是先進後出的隊列，他們是如此的一一對應，以致於永遠都不可能有一個內存塊從棧中間彈出，在他

彈出以前，在他上面的後進的棧內容已經被彈出，詳細的能夠參考數據結構。
　　生長方向：對於堆來說，生長方向是向上的，也就是向着內存地址增長的方向；對於棧來說，它的生長方向是向下的，是向着內

存地址減少的方向增加。
　　分配方式：堆都是動態分配的，沒有靜態分配的堆。棧有2種分配方式：靜態分配和動態分配。靜態分配是編譯器完成的，好比

局部變量的分配。動態分配由malloca函數進行分配，可是棧的動態分配和堆是不一樣的，他的動態分配是由編譯器進行釋放，無需我

們手工實現。
　　分配效率：棧是機器系統提供的數據結構，計算機會在底層對棧提供支持：分配專門的寄存器存放棧的地址，壓棧出棧都有專門

的指令執行，這就決定了棧的效率比較高。堆則是C/C++函數庫提供的，它的機制是很複雜的，例如爲了分配一塊內存，庫函數會按

照必定的算法（具體的算法能夠參考數據結構/操做系統）在堆內存中搜索可用的足夠大小的空間，若是沒有足夠大小的空間（可能

是因爲內存碎片太多），就有可能調用系統功能去增長程序數據段的內存空間，這樣就有機會分 到足夠大小的內存，而後進行返回

。顯然，堆的效率比棧要低得多。
　　從這裏咱們能夠看到，堆和棧相比，因爲大量new/delete的使用，容易形成大量的內存碎片；因爲沒有專門的系統支持，效率很

低；因爲可能引起用戶態和核心態的切換，內存的申請，代價變得更加昂貴。因此棧在程序中是應用最普遍的，就算是函數的調用也

利用棧去完成，函數調用過程當中的參數，返回地址， EBP和局部變量都採用棧的方式存放。因此，咱們推薦你們儘可能用棧，而不是用

堆。
　　雖然棧有如此衆多的好處，可是因爲和堆相比不是那麼靈活，有時候分配大量的內存空間，仍是用堆好一些。
　　不管是堆仍是棧，都要防止越界現象的發生（除非你是故意使其越界），由於越界的結果要麼是程序崩潰，要麼是摧毀程序的堆

、棧結構，產生以想不到的結果。
4.new/delete與malloc/free比較
　　從C++角度上說，使用new分配堆空間能夠調用類的構造函數，而malloc()函數僅僅是一個函數調用，它不會調用構造函數，它所

接受的參數是一個unsigned long類型。一樣，delete在釋放堆空間以前會調用析構函數，而free函數則不會。
　　class Time{
　　public:
　　Time(int,int,int,string);
　　~Time(){
　　cout<<"call Time’s destructor by:"<<name<<endl;
　　}
　　private:
　　int hour;
　　int min;
　　int sec;
　　string name;
　　};
　　Time::Time(int h,int m,int s,string n){
　　hour=h;
　　min=m;
　　sec=s;
　　name=n;
　　cout<<"call Time’s constructor by:"<<name<<endl;
　　}
　　int main(){
　　Time *t1;
　　t1=(Time*)malloc(sizeof(Time));
　　free(t1);
　　Time *t2;
　　t2=new Time(0,0,0,"t2");
　　delete t2;
　　system("PAUSE");
　　return EXIT_SUCCESS;
　　}
　　結果：
　　call Time’s constructor by:t2
　　call Time’s destructor by:t2
　　從結果能夠看出，使用new/delete能夠調用對象的構造函數與析構函數，而且示例中調用的是一個非默認構造函數。但在堆上分

配對象數組時，只能調用默認構造函數，不能調用其餘任何構造函數。