如果读过我之前的文章就会知道，程序构建大概需要经历四个过程：预处理、编译、汇编、链接，这里主要介绍链接这一过程。

链接链的是什么？

链接链的就是目标文件，什么是目标文件？目标文件就是源代码编译后但未进行链接的那些中间文件，如Linux下的.o，它和可执行文件的内容和结构很相似，格式几乎是一样的，可以看成是同一种类型的文件，Linux下统称为ELF文件，这里介绍下ELF文件标准：

• 可重定位文件：Linux中的.o，这类文件包含代码和数据，可被链接成可执行文件或共享目标文件，例如静态链接库。
• 可执行文件：可以直接执行的文件，如/bin/bash文件。
• 共享目标文件：Linux中的.so，包含代码和数据，一种是链接器可以使用这种文件和其它的可重定位文件和共享目标文件链接，另一种是动态链接器可以将几个这种共享目标文件和可执行文件结合，作为进程映像的一部分来执行。
• core dump文件：进程意外终止时，系统可以将该进程的地址空间的内容和其它信息存到coredump文件用于调试，如gdb。
  
  

我们可以使用command file来查看文件的格式：

• file test.o; file /bin/bash;
  ' U" I% e. O  Y  f+ a

目标文件的构成

目标文件主要分为文件头、代码段、数据段和其它。

文件头：描述整个文件的文件属性（文件是否可执行、是静态链接还是动态链接、入口地址、目标硬件、目标操作系统等信息），还包括段表，用来描述文件中各个段的数组，描述文件中各个段在文件中的偏移位置和段属性。

代码段：程序源代码编译后的机器指令。

数据段：数据段分为.data段和.bss段。

.data段内容：已经初始化的全局变量和局部静态变量

.bss段内容：未初始化的全局变量和局部静态变量，.bss段只是为未初始化的全局变量和局部静态变量预留位置，本身没有内容，不占用空间。

除了代码段和数据段，还有.rodata段、.comment、字符串表、符号表和堆栈提示段等等，还可以自定义段。

.bss段不占用存储空间？

看下面代码：

1. 
   9 T  k$ n5 y6 a" f6 @
2. #include <stdio.h>
   
3. 
   $ S* y  D# L7 H- ]& [& |  @& {
4. int a[1000];
   - C! |* L+ }2 x& U: ]; R. n
5. int b[1000] = {1};
   # U2 h) ?/ R  e- [
6. 
   & j; y' S& M6 f( `* y
7. int main() {
   
8.    printf("程序喵\n");
   ! Y& P. m3 ], J% n+ V
9.    return 0;
   7 K6 q- _0 y8 q
10. }

复制代码

; M: `0 H" z& s4 I5 ^! N$ f( e

我们查看下文件大小和各个段大小：

1. 
     Z5 w6 q, I0 G" b% I" u$ g4 t
2. $ gcc testlink.c -o test
   
3. $ ls -l test
   7 z. p) s/ O% j3 V6 r
4. -rwxrwxrwx 1 wzq wzq 12368 May 30 08:48 test
   
5. $ size test
   - ^) |9 [% f" d$ Z. N
6. text   data     bss     dec     hex filename
   % h9 f2 L  d" O" A/ q
7. 1512   4616   4032   10160   27b0 test

复制代码

再看这段初始化的代码：

1. 
   1 K9 {4 z' i' h4 C- u/ j
2. #include <stdio.h>
   
3. 
   4 J7 P( i, P( x; @9 o
4. int a[1000] = {1};
   
5. int b[1000] = {1};
   
6. 
   - D9 D/ f1 l& s% C' D' J8 }$ f9 t
7. int main() {
   
8.    printf("程序喵\n");
   : U2 U8 C* r. ]( L; L' o
9.    return 0;
   
10. }

复制代码

0 \: ~; b( C( K' L" n$ Z

再查看下文件大小和各个段大小：

1. 
   3 k+ r7 {5 E. f" J
2. $ gcc testlink.c -o test
   8 |8 s8 Y  w& j
3. $ ls -l test
   
4. -rwxrwxrwx 1 wzq wzq 16368 May 30 08:49 test
   
5. $ size test
   : l% h0 k9 F: |. e7 O- t9 h
6. text   data     bss     dec     hex filename
   
7. 1512   8616       8   10136   2798 test

复制代码

! R" S0 j$ W5 T# H* }4 N3 c. R

可以看到仅仅是做了一次初始化，文件大小就从12368变成了16368，正好是初始化了的那a[1000]的大小，这4000字节从.bss段移动到了.data段，程序大小增加了，这里可以看出.bss段不占据磁盘空间。

既然.bss段不占据空间，那它的大小和符号存在哪呢？

• .bss段占据的大小存放在ELF文件格式中的段表(Section Table)中，段表存放了各个段的各种信息，比如段的名字、段的类型、段在elf文件中的偏移、段的大小等信息。同时符号存放在符号表.symtab中。
  
  4 |& p. G2 @- A% [

• .bss不占据实际的磁盘空间，只在段表中记录大小，在符号表中记录符号。当文件加载运行时，才分配空间以及初始化。
  
  ! V/ u) [* [( f3 |

其实程序里还有好多系统保留段，还可以自定义段，将某个变量放在自定义段，如下：

• __attribute__((section("Custom"))) int global = 1;
  + ^' O- }: q/ B% w* I

可以使用一些工具查看ELF文件头以及各个段的内容：
$ Z! ?" A- R$ ~' {( C+ q7 V0 J

查看文件头：

1. 
   8 Q* S# Z0 i- y' G+ t
2. $ readelf -h test.o
   6 }3 A, a5 I+ e- S& T+ n
3. ELF Header:
   
4. Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
   
5. Class:                             ELF64
   
6. Data:                              2's complement, little endian
   
7. Version:                           1 (current)
   
8. OS/ABI:                            UNIX - System V
   
9. ABI Version:                       0
   3 }1 k& Q8 Z& A7 W1 B3 U9 n5 |& m
10. Type:                              REL (Relocatable file)
    
11. Machine:                           Advanced Micro Devices X86-64
    * Y( B# o( k% Y, H) U
12. Version:                           0x1
    
13. Entry point address:               0x0
    : h( @9 ]; K* o9 J
14. Start of program headers:          0 (bytes into file)
    / n  y3 C6 C: A% B" @
15. Start of section headers:          720 (bytes into file)
    - r: V2 K; n8 F
16. Flags:                             0x0
    ) s7 W& i8 `" x! t4 e
17. Size of this header:               64 (bytes)
    # p' H2 Y- C, t0 W, @+ u% l
18. Size of program headers:           0 (bytes)
    # f: U) |' J! w4 M
19. Number of program headers:         0
    8 W1 ?* @' L  m8 T4 E
20. Size of section headers:           64 (bytes)
    
21. Number of section headers:         13
    1 j, e# L( w7 R5 Y
22. Section header string table index: 12
    ; Z" y( i( K% G

复制代码

可以使用readelf查看文件头：ELF魔数、文件机器字节长度、数据存储方式、版本、运行平台、ABI版本、ELF重定位类型、硬件平台、硬件平台版本、入口地址、程序头入口和长度、段表的位置和长度和段的数量。
0 _0 R" H; O7 C+ }5 D

查看段表的方法：

使用objdump查看ELF文件中包含的关键的段：

1. 
   ! H5 c9 j8 N- c4 J& ?. s, y. X
2. $ objdump -h test.o
   
3. 
   * A9 ~# `" N% p5 i/ ^# U$ Y2 o& v! t
4. test.o:     file format elf64-x86-64
   ; B$ s8 p$ M) e1 f
5. 
   
6. Sections:
   
7. Idx Name          Size      VMA               LMA               File off  Algn
   8 I9 o, {$ d, m! B* q
8. 0 .text         00000017  0000000000000000  0000000000000000  00000040  2**0
   4 h; s- g# o; ^6 d3 Q( U% {* _) m
9.                  CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
   
10. 1 .data         00000000  0000000000000000  0000000000000000  00000057  2**0
    5 r2 H) E% O% h7 `6 U: j3 a
11.                  CONTENTS, ALLOC, LOAD, DATA
    5 H" y$ c. G3 p/ l. c, l
12. 2 .bss          00000000  0000000000000000  0000000000000000  00000057  2**0
    
13.                  ALLOC
    ; y9 Y6 I" f/ F2 w7 x! m
14. 3 .rodata       00000010  0000000000000000  0000000000000000  00000057  2**0
    2 @6 Y4 G  Z/ r( }: r
15.                  CONTENTS, ALLOC, LOAD, READONLY, DATA
    
16. 4 .comment      0000002a  0000000000000000  0000000000000000  00000067  2**0
    
17.                  CONTENTS, READONLY
    & @6 j$ w. R! `. T  E/ v1 A
18. 5 .note.GNU-stack 00000000  0000000000000000  0000000000000000  00000091  2**0
    
19.                  CONTENTS, READONLY
    
20. 6 .eh_frame     00000038  0000000000000000  0000000000000000  00000098  2**3
    
21.                  CONTENTS, ALLOC, LOAD, RELOC, READONLY, DATA

复制代码

使用readelf查看ELF文件中包含的段：

1. 
   
2. $ readelf -S test.o
   9 T5 k1 Y9 ]" \
3. There are 13 section headers, starting at offset 0x2d0:
   & t- m# }. }& |
4. 
   6 c  ]) z0 i. \2 {' O2 o
5. Section Headers:
   
6. [Nr] Name              Type             Address           Offset
     Z7 ]# z2 n; S, U' Y6 }
7.       Size              EntSize          Flags  Link  Info  Align
   
8. [ 0]                   NULL             0000000000000000  00000000
   
9.       0000000000000000  0000000000000000           0     0     0
   ( O: ]6 H) U& F) r$ R/ V+ T- C
10. [ 1] .text             PROGBITS         0000000000000000  00000040
    
11.       0000000000000017  0000000000000000  AX       0     0     1
    
12. [ 2] .rela.text        RELA             0000000000000000  00000220
    $ Z7 W- x) P* M- k  e
13.       0000000000000030  0000000000000018   I      10     1     8
    - {) @  V$ J" j; q4 p9 o1 h
14. [ 3] .data             PROGBITS         0000000000000000  00000057
    ' {8 C7 T) `; ]& `1 J# K1 [5 E
15.       0000000000000000  0000000000000000  WA       0     0     1
    : U: w* }0 `9 Z( m6 n
16. [ 4] .bss              NOBITS           0000000000000000  00000057
    2 z' Q+ U# [/ s
17.       0000000000000000  0000000000000000  WA       0     0     1
    
18. [ 5] .rodata           PROGBITS         0000000000000000  00000057
    ( G+ G* {; S- e; S
19.       0000000000000010  0000000000000000   A       0     0     1
    ( m, Q  K7 C& `7 v& z: G7 V
20. [ 6] .comment          PROGBITS         0000000000000000  00000067
    8 B* k: E/ M( F( L6 t& x. z
21.       000000000000002a  0000000000000001  MS       0     0     1
    0 i0 N0 F) k: i- h( K
22. [ 7] .note.GNU-stack   PROGBITS         0000000000000000  00000091
    
23.       0000000000000000  0000000000000000           0     0     1
    
24. [ 8] .eh_frame         PROGBITS         0000000000000000  00000098
    
25.       0000000000000038  0000000000000000   A       0     0     8
    ' }2 u; [8 ^6 K8 C" R7 j$ ^
26. [ 9] .rela.eh_frame    RELA             0000000000000000  00000250
    
27.       0000000000000018  0000000000000018   I      10     8     8
    
28. [10] .symtab           SYMTAB           0000000000000000  000000d0
    
29.       0000000000000120  0000000000000018          11     9     8
    ( A! L+ Q8 G5 w" x" c
30. [11] .strtab           STRTAB           0000000000000000  000001f0
    & P  ]$ G# N5 e4 H
31.       000000000000002b  0000000000000000           0     0     1
    
32. [12] .shstrtab         STRTAB           0000000000000000  00000268
    - k& X# @( e, s2 m* V. N! v
33.       0000000000000061  0000000000000000           0     0     1
    
34. Key to Flags:
    
35. W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
    , Y7 o2 U7 @  v1 D! }, t
36. L (link order), O (extra OS processing required), G (group), T (TLS),
    
37. C (compressed), x (unknown), o (OS specific), E (exclude),
    5 B- m9 h+ ?  y* z$ T. [9 G
38. l (large), p (processor specific)

复制代码

objdump只能查看关键的段，而readelf可以查看所有段。

其中，.rela.text是针对.text段的重定位表，链接器在处理目标文件时，需要对目标文件中的某些部位进行重定位，即代码段和数据段那些对绝对地址的引用的位置，这些重定位的信息都会放在.rela.text中，.rel开头的都是用于重定位。

LINK表示符号表的下标，INFO表示它作用于哪个段，值是相应段的下标。

字符串表(.strtab)：保存普通字符串，比如符号名字。

段表字符串表(.shstrtab)：保存段表中用到的字符串，比如段名。

ELF文件头和段表都有各自的结构体，这里不列举，只需要知道它里面存储的是什么东西就好。

程序为什么要分成数据段和代码段

• 数据和指令被映射到两个虚拟内存区域，数据段对进程来说可读写，代码段是只读，这样可以防止程序的指令被有意无意的改写。
  
  

• 有利于提高程序局部性，现代CPU缓存一般被设计成数据缓存和指令缓存分离，分开对CPU缓存命中率有好处。
  
  

• 代码段是可以共享的，数据段是私有的，当运行多个程序的副本时，只需要保存一份代码段部分。
  
  

经典语录：真正了不起的程序员对自己程序的每一个字节都了如指掌。

链接器通过什么进行的链接

链接的接口是符号，在链接中，将函数和变量统称为符号，函数名和变量名统称为符号名。链接过程的本质就是把多个不同的目标文件之间相互“粘”到一起，像玩具积木一样各有凹凸部分，有固定的规则可以拼成一个整体。

可以将符号看作是链接中的粘合剂，整个链接过程基于符号才可以正确完成，符号有很多类型，主要有局部符号和外部符号，局部符号只在编译单元内部可见，对于链接过程没有作用，在目标文件中引用的全局符号，却没有在本目标文件中被定义的叫做外部符号，以及定义在本目标文件中的可以被其它目标文件引用的全局符号，在链接过程中发挥重要作用。

可以使用一些命令来查看符号信息：

command nm：

1. 
   
2. $ nm test.o
   / q. s" |1 {5 }6 e* p; W
3.                 U _GLOBAL_OFFSET_TABLE_
   : y7 ^# y# C, A% x; ~4 T
4. 0000000000000000 T main
   
5.                 U puts

复制代码

( R9 I6 y7 x# n7 f# A2 R& d

command objdump：

1. 
   
2. objdump -t test.o
   
3. 
   
4. test.o:     file format elf64-x86-64
   
5. 
   
6. SYMBOL TABLE:
   
7. 0000000000000000 l    df *ABS*  0000000000000000 test_c.cc
   % s) F4 B" W8 C# T9 {( d  D+ q' X& I
8. 0000000000000000 l    d .text  0000000000000000 .text
   
9. 0000000000000000 l    d .data  0000000000000000 .data
   , r# V& L6 ^1 d7 y
10. 0000000000000000 l    d .bss   0000000000000000 .bss
    
11. 0000000000000000 l    d .rodata        0000000000000000 .rodata
    ; y* `0 `4 h" F+ |# R, f% {
12. 0000000000000000 l    d .note.GNU-stack        0000000000000000 .note.GNU-stack
    
13. 0000000000000000 l    d .eh_frame      0000000000000000 .eh_frame
    3 ]/ S4 [) r# x! l
14. 0000000000000000 l    d .comment       0000000000000000 .comment
    ) b' w" Y6 x* d4 H+ I
15. 0000000000000000 g     F .text  0000000000000017 main
    
16. 0000000000000000         *UND*  0000000000000000 _GLOBAL_OFFSET_TABLE_
    
17. 0000000000000000         *UND*  0000000000000000 puts

复制代码

! i% j, p! e$ H' h. U% i- W

command readelf：

1. 
   
2. readelf -s test.o
   
3. 
   
4. Symbol table '.symtab' contains 12 entries:
   + }  ?; R* ]$ z
5.   Num:    Value          Size Type    Bind   Vis      Ndx Name
   , K0 }  L5 z  n1 N
6.     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND
   
7.     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS test_c.cc
   ( s. C; p  u' f4 a
8.     2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1
   
9.     3: 0000000000000000     0 SECTION LOCAL  DEFAULT    3
   
10.     4: 0000000000000000     0 SECTION LOCAL  DEFAULT    4
    
11.     5: 0000000000000000     0 SECTION LOCAL  DEFAULT    5
    ) y3 D( C+ W3 c9 M. B% `6 }7 a
12.     6: 0000000000000000     0 SECTION LOCAL  DEFAULT    7
    
13.     7: 0000000000000000     0 SECTION LOCAL  DEFAULT    8
    4 U6 r# m" u$ F4 I! n% {" ^
14.     8: 0000000000000000     0 SECTION LOCAL  DEFAULT    6
    
15.     9: 0000000000000000    23 FUNC    GLOBAL DEFAULT    1 main
    ) D; i! v" G2 b$ N; b0 s
16.    10: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _GLOBAL_OFFSET_TABLE_
    ( w1 _0 }: Z; `0 C6 m% N
17.    11: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND puts

复制代码

有些符号在程序中并没有被定义，但是可以直接声明并且引用的符号称为特殊符号，这些符号其实是定义在ld链接器脚本中的，如下面代码中的符号：

1. 
   
2. #include <stdio.h>
   ) V) }% I: S- l
3. 
   # C. x) ]! T) [( I, T" R) P
4. extern char __executable_start[];
     G$ Z# Y1 n. \6 C
5. extern char etext[], _etext[], __etext[];
   
6. extern char edata[], _edata[];
   
7. extern char end[], _end[];
   7 X& o) D8 S. c/ Q8 f5 V
8. 
   - C+ I; |1 Q" m! l
9. int main() {
   
10.    printf("Executable Start %X \n", __executable_start);
    ; H8 a9 h$ T5 h2 F4 ~; h+ |# {
11.    printf("Text End %X %X %X \n", etext, _etext, __etext);
    
12.    printf("Data End %X %X \n", edata, _edata);
    % x% ?% v* m' ^$ U) C& h* E
13.    printf("Executable End %X %X \n", end, _end);
    
14.    return 0;
    8 V. C$ z( o1 N& m6 C
15. }

复制代码

输出：

1. 
   
2. $ ./a.out
   
3. Executable Start 68800000
   : E  i0 `3 K5 M: i# D* L* i
4. Text End 6880075D 6880075D 6880075D
   
5. Data End 68A01010 68A01010
   9 o6 r# `- A) f9 }, a  c
6. Executable End 68A01018 68A01018
   " m. C; o" M$ X! a: g$ Q+ [) `7 Z

复制代码

* R4 P; z* k1 K  I3 X1 t( |( ?为什么需要extern "C"

C语言函数和变量的符号名基本就是函数名字变量名字，不同模块如果有相同的函数或变量名字就会产生符号冲突无法链接成功的问题，所以C++引入了命名空间来解决这种符号冲突问题。同时为了支持函数重载C++也会根据函数名字以及命名空间以及参数类型生成特殊的符号名称。

由于C语言和C++的符号修饰方式不同，C语言和C++的目标文件在链接时可能会报错说找不到符号，所以为了C++和C兼容，引入了extern "C"，当引用某个C语言的函数时加extern "C"告诉编译器对此函数使用C语言的方式来链接，如果C++的函数用extern "C"声明，则此函数的符号就是按C语言方式生成的。

以memset函数举例，C语言中以C语言方式来链接，但是在C++中以C++方式来链接就会找不到这个memset的符号，所以需要使用extern "C"方式来声明这个函数，为了兼容C和C++，可以使用宏来判断，用条件宏判断当前是不是C++代码，如果是C++代码则extern "C"。

1. 
   
2. #ifdef __cplusplus
   . _2 M# [  i( @8 k
3. extern "C" {
   
4. #endif
   " b$ n5 X; s: ~! u  [- s1 s
5. 
   5 n' `5 p  p! I$ N3 O0 v
6. void *memset(void *, int, size_t);
   
7. 
   : a5 O1 U8 q3 j( ~" Z( D8 Y# f
8. #ifdef __cplusplus
   - i( a! p: M+ N, m+ T; f
9. }
   ' ^! [& r1 }, X; j0 `, L
10. #endif

复制代码

这种技巧几乎在所有的系统头文件中都会被用到。

强符号和弱符号

我们经常编程中遇到的multiple definition of 'xxx'，指的是多个目标中有相同名字的全局符号的定义，产生了冲突，这种符号的定义指的是强符号。有强符号自然就有弱符号，编译器默认函数和初始化了的全局变量为强符号，未初始化的全局变量为弱符号。__attribute__((weak))可以定义弱符号。

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   6 U1 x, }4 F; N* [8 f3 d
2. extern int ext;
   
3. 
   4 R, C" D  S% I4 T' J% _
4. int weak; // 弱符号
   
5. int strong = 1; // 强符号
   2 P9 I% z$ W/ U
6. __attribute__((weak)) int weak2 = 2; // 弱符号
   & p( W: S& \' O$ y) z$ F5 f
7. 
   
8. int main() {
   
9.    return 0;
   
10. }</font></font></font>
    ! P; ^' k/ b% E% F

复制代码

链接器规则：

• 不允许强符号被多次定义，多次定义就会multiple definition of 'xxx'
• 一个符号在一个目标文件中是强符号，在其它目标文件中是弱符号，选择强符号
• 一个符号在所有目标文件中都是弱符号，选择占用空间最大的符号，int类型和double类型选double类型
  
  

强引用和弱引用

一般引用了某个函数符号，而这个函数在任何地方都没有被定义，则会报错error: undefined reference to 'xxx'，这种符号引用称为强引用。与此对应的则有弱引用，链接器对强引用弱引用的处理过程几乎一样，只是对于未定义的弱引用，链接器不会报错，而是默认其是一个特殊的值。

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   3 k  Z8 _) m% j4 `9 y
2. __attribute__ ((weak)) void foo();
   
3. 
   
4. int main() {
   
5.    foo();
   
6.    return 0;
   ' \5 y2 x4 V- N$ r
7. }</font></font></font>
   

复制代码

这里可以编译链接成功，运行此可执行程序，会报非法地址错误，所以可以做下面的改进：

1. 
   7 P1 o  E( s' E/ _( [6 j
2. __attribute__ ((weak)) void foo();
   * c8 {  |- ?% V/ [8 j) L3 r3 ?
3. 
   ) ~. }9 p. {, d: C3 |; ?. s' ~
4. int main() {
   ; v6 q" M4 T6 K6 S5 T
5.    if (foo) {
   , n+ N! u5 A2 q4 h' [
6.        foo();
   3 E* `' O! F) ]7 f
7.   }
   ' Z* H# t2 y+ E! I' J. f- ?% J1 @
8.    return 0;
   
9. }

复制代码

这种强引用弱引用对于库来说十分有用，库中的弱引用可以被用户定义的强引用所覆盖，这样程序就可以使用自定义版本的库函数，可以将引用定义为弱引用，如果去掉了某个功能，也可以正常连接接，想增加相应功能还可以直接增加强引用，方便程序的裁剪和组合。

如下：

1. 
   + K& B; `  D& d: [
2. // test2.c
   
3. #include <stdio.h>
   * A( z; H9 t1 c. P- h* n
4. 
   
5. void foo() {
   
6.    printf("foo2\n");
   
7. }

复制代码

1. 
   8 l% k* o& |, I( L
2. // test3.c
   
3. #include <stdio.h>
   
4. 
   
5. void foo() {
   9 A% d! E& e- ^" L
6.    printf("foo3\n");
   : K4 T" n0 P, g3 V8 J% i+ ^9 t
7. }

复制代码

) v6 r: B; p. H# F5 h/ g

使用如下方式链接：

1. 
   $ a) l8 J7 d6 ]/ C
2. $ gcc test.c -o a.out
   
3. $ ./a.out
   2 T+ N9 p' U7 U" B" @
4. 什么都不会输出
   # A' K+ w5 C; r) f0 \
5. $ gcc test.c test2.c -o a.out
   " o1 {8 l8 D( G. I* r1 v
6. $ ./a.out
   4 Z: \* Q. M, R- L; g/ g
7. foo2
   " L8 Y, S2 b; _2 E( ?
8. $ gcc test.c test3.c -o a.out
   
9. $ ./a.out
   , E/ b. ?6 W, V- A( n
10. foo3

复制代码

对于弱符号和弱引用，其都仅是GNU工具链GCC对C语言语法的扩展，并不是C本身的语言特性。