3. 变量的存储布局

首先看下面的例子：

例 19.2. 研究变量的存储布局

  1. #include <stdio.h>
  2.  
  3. const int A = 10;
  4. int a = 20;
  5. static int b = 30;
  6. int c;
  7.  
  8. int main(void)
  9. {
  10.     static int a = 40;
  11.     char b[] = "Hello world";
  12.     register int c = 50;
  13.  
  14.     printf("Hello world %d\n", c);
  15.  
  16.     return 0;
  17. }

我们在全局作用域和main函数的局部作用域各定义了一些变量，并且引入一些新的关键字const、static、register来修饰变量，那么这些变量的存储空间是怎么分配的呢？我们编译之后用readelf命令看它的符号表，了解各变量的地址分布。注意在下面的清单中我把符号表按地址从低到高的顺序重新排列了，并且只截取我们关心的那几行。

  1. $ gcc main.c -g
  2. $ readelf -a a.out
  3. ...
  4.     68: 08048540     4 OBJECT  GLOBAL DEFAULT   15 A
  5.     69: 0804a018     4 OBJECT  GLOBAL DEFAULT   23 a
  6.     52: 0804a01c     4 OBJECT  LOCAL  DEFAULT   23 b
  7.     53: 0804a020     4 OBJECT  LOCAL  DEFAULT   23 a.1589
  8.     81: 0804a02c     4 OBJECT  GLOBAL DEFAULT   24 c
  9. ...

变量A用const修饰，表示A是只读的，不可修改，它被分配的地址是0x8048540，从readelf的输出可以看到这个地址位于.rodata段：

  1. Section Headers:
  2.   [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  3. ...
  4.   [13] .text             PROGBITS        08048360 000360 0001bc 00  AX  0   0 16
  5. ...
  6.   [15] .rodata           PROGBITS        08048538 000538 00001c 00   A  0   0  4
  7. ...
  8.   [23] .data             PROGBITS        0804a010 001010 000014 00  WA  0   0  4
  9.   [24] .bss              NOBITS          0804a024 001024 00000c 00  WA  0   0  4
  10. ...

它在文件中的地址是0x538~0x554，我们用hexdump命令看看这个段的内容：

  1. $ hexdump -C a.out
  2. ...
  3. 00000530  5c fe ff ff 59 5b c9 c3  03 00 00 00 01 00 02 00  |\...Y[..........|
  4. 00000540  0a 00 00 00 48 65 6c 6c  6f 20 77 6f 72 6c 64 20  |....Hello world |
  5. 00000550  25 64 0a 00 00 00 00 00  00 00 00 00 00 00 00 00  |%d..............|
  6. ...

其中0x540地址处的0a 00 00 00就是变量A。我们还看到程序中的字符串字面值"Hello world %d\n"分配在.rodata段的末尾，在第 4 节 “字符串”说过字符串字面值是只读的，相当于在全局作用域定义了一个const数组：

  1. const char helloworld[] = {'H', 'e', 'l', 'l', 'o', ' ',
  2.              'w', 'o', 'r', 'l', 'd', ' ', '%', 'd', '\n', '\0'};

程序加载运行时，.rodata段和.text段通常合并到一个Segment中，操作系统将这个Segment的页面只读保护起来，防止意外的改写。这一点从readelf的输出也可以看出来：

  1.  Section to Segment mapping:
  2.   Segment Sections...
  3.    00     
  4.    01     .interp 
  5.    02     .interp .note.ABI-tag .hash .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rel.dyn .rel.plt .init .plt .text .fini .rodata .eh_frame 
  6.    03     .ctors .dtors .jcr .dynamic .got .got.plt .data .bss 
  7.    04     .dynamic 
  8.    05     .note.ABI-tag 
  9.    06     
  10.    07     .ctors .dtors .jcr .dynamic .got

注意，像A这种const变量在定义时必须初始化。因为只有初始化时才有机会给它一个值，一旦定义之后就不能再改写了，也就是不能再赋值了。

从上面readelf的输出可以看到.data段从地址0x804a010开始，长度是0x14，也就是到地址0x804a024结束。在.data段中有三个变量，a，b和a.1589。

a是一个GLOBAL的符号，而b被static关键字修饰了，导致它成为一个LOCAL的符号，所以static在这里的作用是声明b这个符号为LOCAL的，不被链接器处理，在下一章我们会看到，如果把多个目标文件链接在一起，LOCAL的符号只能在某一个目标文件中定义和使用，而不能定义在一个目标文件中却在另一个目标文件中使用。一个函数定义前面也可以用static修饰，表示这个函数名符号是LOCAL的。

还有一个a.1589是什么呢？它就是main函数中的static int a。函数中的static变量不同于以前我们讲的局部变量，它并不是在调用函数时分配，在函数返回时释放，而是像全局变量一样静态分配，所以用“static”（静态）这个词。另一方面，函数中的static变量的作用域和以前讲的局部变量一样，只在函数中起作用，比如main函数中的a这个变量名只在main函数中起作用，在别的函数中说变量a就不是指它了，所以编译器给它的符号名加了一个后缀，变成a.1589，以便和全局变量a以及其它函数的变量a区分开。

.bss段从地址0x804a024开始（紧挨着.data段），长度为0xc，也就是到地址0x804a030结束。变量c位于这个段。从上面的readelf输出可以看到，.data和.bss在加载时合并到一个Segment中，这个Segment是可读可写的。.bss段和.data段的不同之处在于，.bss段在文件中不占存储空间，在加载时这个段用0填充。所以我们在第 4 节 “全局变量、局部变量和作用域”讲过，全局变量如果不初始化则初值为0，同理可以推断，static变量（不管是函数里的还是函数外的）如果不初始化则初值也是0，也分配在.bss段。

现在还剩下函数中的b和c这两个变量没有分析。上一节我们讲过函数的参数和局部变量是分配在栈上的，b是数组也一样，也是分配在栈上的，我们看main函数的反汇编代码：

  1. $ objdump -dS a.out
  2. ...
  3.         char b[]="Hello world";
  4.  8048430:       c7 45 ec 48 65 6c 6c    movl   $0x6c6c6548,-0x14(%ebp)
  5.  8048437:       c7 45 f0 6f 20 77 6f    movl   $0x6f77206f,-0x10(%ebp)
  6.  804843e:       c7 45 f4 72 6c 64 00    movl   $0x646c72,-0xc(%ebp)
  7.         register int c = 50;
  8.  8048445:       b8 32 00 00 00          mov    $0x32,%eax
  9.  
  10.         printf("Hello world %d\n", c);
  11.  804844a:       89 44 24 04             mov    %eax,0x4(%esp)
  12.  804844e:       c7 04 24 44 85 04 08    movl   $0x8048544,(%esp)
  13.  8048455:       e8 e6 fe ff ff          call   8048340 <printf@plt>
  14. ...

可见，给b初始化用的这个字符串"Hello world"并没有分配在.rodata段，而是直接写在指令里了，通过三条movl指令把12个字节写到栈上，这就是b的存储空间，如下图所示。

图 19.4. 数组的存储布局

数组的存储布局

注意，虽然栈是从高地址向低地址增长的，但数组总是从低地址向高地址排列的，按从低地址到高地址的顺序依次是b[0]、b[1]、b[2]……这样，

数组元素b[n]的地址 = 数组的基地址（b做右值就表示这个基地址） + n × 每个元素的字节数

当n=0时，元素b[0]的地址就是数组的基地址，因此数组下标要从0开始而不是从1开始。

变量c并没有在栈上分配存储空间，而是直接存在eax寄存器里，后面调用printf也是直接从eax寄存器里取出c的值当参数压栈，这就是register关键字的作用，指示编译器尽可能分配一个寄存器来存储这个变量。我们还看到调用printf时对于"Hello world %d\n"这个参数压栈的是它在.rodata段中的首地址，而不是把整个字符串压栈，所以在第 4 节 “字符串”中说过，字符串在使用时可以看作数组名，如果做右值则表示数组首元素的地址（或者说指向数组首元素的指针），我们以后讲指针还要继续讨论这个问题。

以前我们用“全局变量”和“局部变量”这两个概念，主要是从作用域上区分的，现在看来用这两个概念给变量分类太笼统了，需要进一步细分。我们总结一下相关的C语法。

作用域（Scope）这个概念适用于所有标识符，而不仅仅是变量，C语言的作用域分为以下几类：

  • 函数作用域（Function Scope），标识符在整个函数中都有效。只有语句标号属于函数作用域。标号在函数中不需要先声明后使用，在前面用一个goto语句也可以跳转到后面的某个标号，但仅限于同一个函数之中。

  • 文件作用域（File Scope），标识符从它声明的位置开始直到这个程序文件[30]的末尾都有效。例如上例中main函数外面的A、a、b、c，还有main也算，printf其实是在stdio.h中声明的，被包含到这个程序文件中了，所以也算文件作用域的。

  • 块作用域（Block Scope），标识符位于一对{}括号中（函数体或语句块），从它声明的位置开始到右}括号之间有效。例如上例中main函数里的a、b、c。此外，函数定义中的形参也算块作用域的，从声明的位置开始到函数末尾之间有效。

  • 函数原型作用域（Function Prototype Scope），标识符出现在函数原型中，这个函数原型只是一个声明而不是定义（没有函数体），那么标识符从声明的位置开始到在这个原型末尾之间有效。例如int foo(int a, int b);中的a和b。

对属于同一命名空间（Name Space）的重名标识符，内层作用域的标识符将覆盖外层作用域的标识符，例如局部变量名在它的函数中将覆盖重名的全局变量。命名空间可分为以下几类：

  • 语句标号单独属于一个命名空间。例如在函数中局部变量和语句标号可以重名，互不影响。由于使用标号的语法和使用其它标识符的语法都不一样，编译器不会把它和别的标识符弄混。

  • struct，enum和union（下一节介绍union）的类型Tag属于一个命名空间。由于Tag前面总是带struct，enum或union关键字，所以编译器不会把它和别的标识符弄混。

  • struct和union的成员名属于一个命名空间。由于成员名总是通过.或->运算符来访问而不会单独使用，所以编译器不会把它和别的标识符弄混。

  • 所有其它标识符，例如变量名、函数名、宏定义、typedef的类型名、enum成员等等都属于同一个命名空间。如果有重名的话，宏定义覆盖所有其它标识符，因为它在预处理阶段而不是编译阶段处理，除了宏定义之外其它几类标识符按上面所说的规则处理，内层作用域覆盖外层作用域。

标识符的链接属性（Linkage）有三种：

  • 外部链接（External Linkage），如果最终的可执行文件由多个程序文件链接而成，一个标识符在任意程序文件中即使声明多次也都代表同一个变量或函数，则这个标识符具有External Linkage。具有External Linkage的标识符编译后在符号表中是GLOBAL的符号。例如上例中main函数外面的a和c，main和printf也算。

  • 内部链接（Internal Linkage），如果一个标识符在某个程序文件中即使声明多次也都代表同一个变量或函数，则这个标识符具有Internal Linkage。例如上例中main函数外面的b。如果有另一个foo.c程序和main.c链接在一起，在foo.c中也声明一个static int b;，则那个b和这个b不代表同一个变量。具有Internal Linkage的标识符编译后在符号表中是LOCAL的符号，但main函数里面那个a不能算Internal Linkage的，因为即使在同一个程序文件中，在不同的函数中声明多次，也不代表同一个变量。

  • 无链接（No Linkage）。除以上情况之外的标识符都属于No Linkage的，例如函数的局部变量，以及不表示变量和函数的其它标识符。

存储类修饰符（Storage Class Specifier）有以下几种关键字，可以修饰变量或函数声明：

  • static，用它修饰的变量的存储空间是静态分配的，用它修饰的文件作用域的变量或函数具有Internal Linkage。

  • auto，用它修饰的变量在函数调用时自动在栈上分配存储空间，函数返回时自动释放，例如上例中main函数里的b其实就是用auto修饰的，只不过auto可以省略不写，auto不能修饰文件作用域的变量。

  • register，编译器对于用register修饰的变量会尽可能分配一个专门的寄存器来存储，但如果实在分配不开寄存器，编译器就把它当auto变量处理了，register不能修饰文件作用域的变量。现在一般编译器的优化都做得很好了，它自己会想办法有效地利用CPU的寄存器，所以现在register关键字也用得比较少了。

  • extern，上面讲过，链接属性是根据一个标识符多次声明时是不是代表同一个变量或函数来分类的，extern关键字就用于多次声明同一个标识符，下一章再详细介绍它的用法。

  • typedef，在第 2.4 节 “sizeof运算符与typedef类型声明”讲过这个关键字，它并不是用来修饰变量的，而是定义一个类型名。在那一节也讲过，看typedef声明怎么看呢，首先去掉typedef把它看成变量声明，看这个变量是什么类型的，那么typedef就定义了一个什么类型，也就是说，typedef在语法结构中出现的位置和前面几个关键字一样，也是修饰变量声明的，所以从语法（而不是语义）的角度把它和前面几个关键字归类到一起。

注意，上面介绍的const关键字不是一个Storage Class Specifier，虽然看起来它也修饰一个变量声明，但是在以后介绍的更复杂的声明中const在语法结构中允许出现的位置和Storage Class Specifier是不完全相同的。const和以后要介绍的restrict和volatile关键字属于同一类语法元素，称为类型限定符（Type Qualifier）。

变量的生存期（Storage Duration，或者Lifetime）分为以下几类：

  • 静态生存期（Static Storage Duration），具有外部或内部链接属性，或者被static修饰的变量，在程序开始执行时分配和初始化一次，此后便一直存在直到程序结束。这种变量通常位于.rodata，.data或.bss段，例如上例中main函数外的A，a，b，c，以及main函数里的a。

  • 自动生存期（Automatic Storage Duration），链接属性为无链接并且没有被static修饰的变量，这种变量在进入块作用域时在栈上或寄存器中分配，在退出块作用域时释放。例如上例中main函数里的b和c。

  • 动态分配生存期（Allocated Storage Duration），以后会讲到调用malloc函数在进程的堆空间中分配内存，调用free函数可以释放这种存储空间。

[30] 为了容易阅读，这里我用了“程序文件”这个不严格的叫法。如果有文件a.c包含了b.h和c.h，那么我所说的“程序文件”指的是经过预处理把b.h和c.h在a.c中展开之后生成的代码，在C标准中称为编译单元（Translation Unit）。每个编译单元可以分别编译成一个.o目标文件，最后这些目标文件用链接器链接到一起，成为一个可执行文件。C标准中大量使用一些非常不通俗的名词，除了编译单元之外，还有编译器叫Translator，变量叫Object，本书不会采用这些名词，因为我不是在写C标准。