數據段

數據段保存靜態變量、常量和一些全局變量，以下是一段示例，兩個函數分別定義了靜態變量 count 和執行了全局變量 globalCount。

#include <stdio.h> 
int globalCount = 0; 
int add(int x, int y) { 
  static int count = 0; 
  count++; 
  globalCount++; 
  return x + y; 
} 
int sub(int x, int y) { 
  static int count = 0;  
  count++; 
  globalCount++; 
  return x + y; 
} 
 
int main() { 
  int a = 6; 
  int b = 3; 
  int s1 = add(a, b); 
  int s2 = sub(a, b); 
  printf("s1=%d s2=%d", s1, s2); 
} 

通過 gdb 調試看下，分別在 add 函數里打印了靜態變量 count 和全局變量 globalCount 的內存地址。

靜態變量 count 是聲明在函數內部的，因此兩次打印出來的地址也是不一樣的，自然兩個是不會相互影響的，全局變量可以看到內存地址是一樣的，因此在任意一個函數里修改，值都會發生變化。

0x601038、0x60103c、0x601040 每次遞增 4 個字節，可以看到它們的內存地址是連續遞增的，數據段的內存地址以 0x6 開頭是大于代碼段的。

add (x=6, y=3) at main2.c:5 
5   count++; 
(gdb) p &count 
$1 = (int *) 0x60103c <count.2181> 
(gdb) p &globalCount 
$2 = (int *) 0x601038 <globalCount> 
 
sub (x=6, y=3) at main2.c:11 
11   count++; 
(gdb) p &count 
$3 = (int *) 0x601040 <count.2186> 
(gdb) p &globalCount 
$4 = (int *) 0x601038 <globalCount> 

數據段還有一種稱為 “BSS” 段，表示未初始化或初始化為 0 的所有全局變量或靜態變量，static int a 或全局變量 int a 稱為 “未初始化數據段”。

關于初始化數據段與未初始化數據段，這里有篇文章講的也很好，可以參考 https://zhuanlan.zhihu.com/p/62208277。

棧段

棧寄存器段，指向包含當前程序棧的段，這些都是臨時的信息。例如：局部變量、函數參數、返回值和當前程序運行狀態等都存在于棧中，隨著這些臨時變量對應的作用域完成之后，也會被彈出棧。

一個變量交換示例

以下為一段 C 語言代碼示例，通過 swap 函數交換兩個變量。

// main.c 
#include <stdio.h> 
void swap(int *a, int *b) { 
  int temp = *a; 
  *a = *b; 
  *b = temp; 
} 
int main() { 
  int a = 2; 
  int b = 3; 
  swap(&a, &b); 
  printf("a=%d b=%d", a, b); 
} 

先使用 gcc 編譯我們的源代碼 gcc -g main.c -o main.out，之后使用 gdb 調試。

問題解答：為什么說棧是一塊連續的內存空間?

在 C 語言里一個整型的數據大小為 4 個字節(指針類型另有規定，后面會講)，整型變量 a 存儲的內存地址為 0x7fffffffe35c 也即首地址，按照 4 Byte 推算應該是 0x7fffffffe35c、0x7fffffffe35d、0x7fffffffe35e、0x7fffffffe35f。整型變量 b 的內存地址為 0x7fffffffe358 同樣按照 4 Byte 推算應該是 0x7fffffffe358、0x7fffffffe359、0x7fffffffe35a、0x7fffffffe35b 也就是加上 4 個字節正好相鄰于變量 a，因此我們還可以在確認一個問題是：“棧是一塊連續的內存區域”。

通過一個圖，相對直觀的感受下。

這時可能會產生一個疑問，為什么創建變量順序是 a、b 而分配的內存地址確是遞減的順序?

這涉及到棧的存儲結構，棧是先進后出的，棧頂的地址是由系統預先設置好的，由棧頂入棧隨后每次內存地址呈遞減的方式依次分配，當還有新元素時就繼續壓棧，最先入棧的最后出棧，也可理解為棧底對應高地址、棧頂對應低地址。

(gdb) p &a 
$1 = (int *) 0x7fffffffe35c 
(gdb) p &b 
$2 = (int *) 0x7fffffffe358 

使用 gdb 調試進入 swap 函數，這兩個參數 a、b 我們定義為指針類型，可以看到它的值為外層整型變量 a 和 b 的內存地址。

swap 函數里的指針類型變量 a 與 b 也是有內存地址的，可以打印出來看下。同樣的可以看出，這兩個內存地址之間相差 8 個字節，也就號符合指針類型的定義，在 64 位系統下一個指針占用 8 個字節，當然大學課本上你可能看到過 1 個指針占用 4 個字節，那是針對的 32 位系統。

swap (a=0x7fffffffe35c, b=0x7fffffffe358) at main.c:3 
3   int temp = *a; 
(gdb) p &a 
$1 = (int **) 0x7fffffffe328 
(gdb) p &b 
$2 = (int **) 0x7fffffffe320 

目前處于代碼的第 3 行，swap 函數里指針變量 a 存儲的是外層傳入的變量 a 的內存地址，如何獲取該值呢?那么在 C 語言中通過運算符 * 號可以取到一個內存地址對應的值，也就是“解引用”。

(gdb) p *a 
$3 = 2 

接下來執行 2 兩步，程序停留在第 5 行，可以看到 a 的值由 2 變為了 3，為什么 swap 函數能交換兩個變量的值，也正是因為我們在這里通過指針修改了傳進來的兩個變量的內存地址。

(gdb) n 
4   *a = *b; 
(gdb) n 
5   *b = temp; 
(gdb) p *a 
$4 = 3 

查看函數堆棧

通過 bt 可以打印當前函數調用棧的所有信息，左側有一個 #0、#1 的序號，0 就是目前的棧頂，因為我們這個程序很簡單，程序入口函數 main() 就是我們的棧底，而當前執行的 swap() 函數就是我們的棧頂，也是當前程序所在的位置。

(gdb) bt 
#0  swap (a=0x7fffffffe35c, b=0x7fffffffe358) at main.c:5 
#1  0x0000000000400582 in main () at main.c:11 

棧溢出

棧是有內存大小限制的，Linux 或 Mac 下我們可通過 ulimit -s 命令查看，結果為：8192 # stack size (kbytes) ，Linux 下用戶默認的棧空間大小為 8MB。

遞歸造成的棧溢出

寫遞歸時，通常要控制好邊界，避免出現無限遞歸，遞歸的層級也不要太深，盡量不要在棧上定義太大的數據。一段遞歸調用的程序如下所示：

#include <stdio.h> 
 
void call() 
{ 
  int a[2048]; 
  printf("hello call! \n"); 
  call(); 
} 
int main(int argc, char *argv[]) { 
  call(); 
} 

gdb 調試之后得到如下錯誤信息：

Program received signal SIGSEGV, Segmentation fault. 
0x000000000040053d in call () at a.c:6 

bt -n 從棧底打印 n 條信息，最下面為我們的 main 函數，除此之外可以看到 call() 總共遞歸調用了 1022 次，因為最上面序號是從 0 開始的。

(gdb) bt -5 
#1018 0x000000000040054c in call () at a.c:7 
#1019 0x000000000040054c in call () at a.c:7 
#1020 0x000000000040054c in call () at a.c:7 
#1021 0x000000000040054c in call () at a.c:7 
#1022 0x0000000000400567 in main (argc=1, argv=0x7fffffffe458) at a.c:10 

問題解答：為什么遞歸會造成棧溢出?

當我們遞歸一個函數時，這個時候每一次的遞歸運行都會做壓棧操作，棧是一種先進后出的數據結構，系統也是有最大的空間限制的，Linux 下用戶默認的棧空間大小為 8MB，當棧的存放容量超出這個限制之后，通常我們的程序會得到棧溢出得到錯誤。

留一個問題大家思考下??：通過上面我們知道了遞歸層級太深會導致棧溢出，這是因為系統會有棧空間大小限制的，筆者平常使用 JavaScript 相會多一些，如果是在 JavaScript 中遇到這種問題怎么解決?不知道也沒關系，筆者最近在寫一個系列文章 《JavaScript 異步編程指南》可以帶你一起深入了解這個問題。

字符數組造成的棧溢出

模擬這個問題很簡單，創建一個過大的字符數組。

#include<stdio.h> 
int main() 
{ 
 char str[8192 * 1024]; 
 int size = sizeof(str); 
 
 printf("size: %d\n", size); 
} 

通過 gdb 調試，會得到一個 “Segmentation fault” 通常也稱為段錯誤，指的是訪問的內存超出了系統給程序設定的內存空間，一般包括：不存在的內存地址、訪問了系統保護的內存地址、訪問了只讀的內存地址、棧溢出等。

Program received signal SIGSEGV, Segmentation fault. 
0x000000000040054e in main () at index.c:7 

解決這種問題，繼續往下看～

堆段

堆段由開發者手動申請分配和釋放，也稱動態內存分配。在 C 語言中可以使用系統提供的函數 malloc() 和 free() 申請和釋放內存。

繼續拿上面 “字符數組棧溢出” 這個示例，現在改成在堆中創建內存，這時僅在棧中保存指針變量 str 的地址，真正數據存放于堆中，也就不會出現棧溢出問題了。

#include <stdio.h> 
#include <malloc.h> 
int main() 
{ 
 char *str = (char *)malloc(8192 * 1024); 
 if (str == NULL) { 
   printf("Heap memory application failed."); 
   return 0; 
 } 
 printf("Heap memory application successed."); 
 
 free(str); 
 str = NULL; 
 return 0; 
} 

進入 gdb 調試，代碼停留在第 5 行，在未分配堆內存之前，打印 str 可以看到是沒有值的，而 &str 取的是該變量在棧空間的內存地址 0x7fffffffe368，這不是一回事，這是該變量的值。

再次執行，創建堆內存，代碼停留在第 12 行 free(str) 打印 str 得到 0x7ffff720c010 這時候堆內存已分配成功。

現在讓我們做釋放操作，代碼停留在 14 行，打印 str 可以看到值已被釋放。

# 未分配 
Temporary breakpoint 1, main () at b.c:5 
5  char *str = (char *)malloc(8192 * 1024); 
(gdb) p str 
$1 = 0x0 
(gdb) p &str 
$2 = (char **) 0x7fffffffe368 
(gdb) n 
 
# 已分配 
6  if (str == NULL) { 
(gdb) n 
10  printf("Heap memory application successed."); 
(gdb) n 
 
# 釋放 
12  free(str); 
(gdb) p str 
$3 = 0x7ffff720c010 "" 
(gdb) n 
13  str = NULL; 
(gdb) n 
14  return 0; 
(gdb) p str 
$4 = 0x0 
(gdb) p &str 
$5 = (char **) 0x7fffffffe368 

總結

本文也是筆者在之前學習過程中的總結，近期又稍微整理下，發出來也是希望能與大家共同的分享、交流。

通過本文，幾個常見的知識點：棧與堆的區別、為什么遞歸會造成棧溢出，類似于這種常見的問題，希望讀者朋友能夠掌握。