Skip to content

本页便签全部 ↗

本页还没有便签

划选正文里的一段文字,点弹出的「✎ 存为便签」,回头在这里一键跳回原处。

编译与链接:从 .cpp 到可执行文件的四个阶段 ​

咱们差不多每天都得敲一遍这样的命令,不敲命令的,也在 IDE 里把构建按钮点了一遍:

bash
g++ hello.cpp -o hello

回车按了下去,过了几秒,一个能直接运行的 hello 就躺在了目录里。那中间的几秒,机器到底做了什么?大多数教程到这儿就翻篇了,好像能跑起来就已经足够了,您也就跟着翻到了下一章。可您多半见过 undefined reference,见过重复定义的报错,或者对着一大串链接错误发了很久的呆。这些让人头疼的东西,全都发生在中间的那几秒里,而那几秒,恰恰是 C++ 工程里最少被人讲到的部分。

笔者想用这一卷,把这几秒钟的事交代清楚。这一卷的第一篇,咱们做一件朴素的事情:您敲的这行命令,背后其实藏着四个阶段,咱们把每个阶段都亲手跑一遍,把中间的产物一个一个拿出来看。跑完之后还有一件可能让您意外的事:您每天敲的 g++,其实自己一行代码都不编译,真正干活的另有其人,后面咱们会亲眼见到它们。

咱们的实验品:六行代码 ​

整个系列咱们就拿它起手:

C++
// hello.cpp
#include <iostream>

int main() {
    std::cout << "hello, linker!\n";
    return 0;
}

咱们一共就写六行,不能再精简了。往终端里敲的虽然是 g++,但今天您会看到,真正露脸的其实是另外三个名字。

笔者在 WSL2(Windows 里的 Linux 子系统)里干活,用的工具链是 GCC 16.2.1,配上的是 binutils 2.47 和 glibc 2.44。binutils 是 GNU 家的一套二进制工具,咱们马上要见到的汇编器、链接器,都是从这里出来的。glibc 则是 GNU 的 C 库,也就是 Linux 上 C/C++ 程序的运行时库。这一篇里出现的所有输出,都是笔者真实跑出来的。您那边版本要是不同,行数、路径之类的细节会有出入,但四个阶段本身倒是几十年没变过。

预处理:源码进,源码出 ​

g++ 还给了咱们几个开关,咱们拿着它们就能把 g++ 拦在半路,把中间的产物留下来。头一个用的就是 -E:预处理做完了,它就停了下来。

bash
g++ -E hello.cpp -o hello.i

这一次的产物是 hello.i。它到底变成了什么样?咱们拿 wc 数一数行数:

text
$ wc -l hello.cpp hello.i
 44971 hello.i
     6 hello.cpp

进去的是六行,出来的是四万四千九百七十一行。笔者第一回看到这个数字,愣是把终端往上滚了半天,滚过去的全是头文件。

这多出来的部分从哪来?就来自咱们写的那行 #include <iostream>。预处理器见了 #include,就把指向的文件原样抄进来。iostream 自己又包含了别的头文件,于是一路抄了下去,抄成了四万多行。咱们这个文件里除了 #include,没写别的预处理指令。宏要是写了,到了这一步也会被展开。注释倒是省事,直接就被拿掉了。

那 hello.i 算什么类型的文件?咱们请 file 命令发言:

text
hello.i:   C++ source, ASCII text

您看,它其实还是 C++ 源代码,货真价实的 ASCII 文本。预处理是源码到源码的文本变换,没有产生任何和机器相关的东西。您现在就可以打开 hello.i 一路拉到最底下,咱们的 main 原封不动躺在那里,它前面是四万多行的头文件展开。

头文件是怎么防止自己被重复抄写的,宏展开还有什么别的花样,条件编译又是干什么用的,这些就都归下一篇了。hello.i 的这四万多行,咱们到时候再回来收拾它。

编译:源码变汇编 ​

轮到第二个开关 -S 了:咱们让 g++ 在生成汇编之后就停。

bash
g++ -S hello.cpp -o hello.s
text
hello.s:   assembler source, ASCII text

出来的还是文本,但已经是另一门语言了。hello.s 的开头长这样,咱们一行一行往下认:

asm
	.file	"hello.cpp"
	.text
	.globl	main
	.type	main, @function
main:
	pushq	%rbp
	movq	%rsp, %rbp
	leaq	.LC0(%rip), %rdx
	leaq	_ZSt4cout(%rip), %rax
	call	_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@PLT

咱们从 main 看起。它的名字还叫 main,只是身份变了:现在它成了汇编里的一个标号,标号下面紧跟的 pushq、movq 两条,是函数开场的老一套,负责把这一帧的栈架起来。

咱们再来看自己写的字符串字面量 "hello, linker!\n",它也变了样子:编译器把它收走了,给了一个内部编号 .LC0,后面的代码要用它的时候,都得拿地址去引用。

_ZSt4cout 这串看着像乱码的东西,其实就是 std::cout。咱们知道 C++ 里有命名空间、有重载,同名的东西又太多,编译器就干脆把这些信息统统编码进了符号名,保证不会重了名。这个动作咱们叫它名字修饰(name mangling)。咱们不用急着会读它,交给 c++filt 就行了,它马上就把本名原样报给咱们。今天咱们只要认识一个代表:cout 到了汇编世界里,名字就成了 _ZSt4cout。

最有看头的就是末尾的那行 call。它调用的函数,笔者替您翻译一下:它就是咱们在用的 operator<<,往 cout 里送字符串的那个重载。有两处地方值得咱们停下来。

您看,operator<< 的实现,根本就不在咱们这六行代码里。咱们只是调用了它,它的实现住在别处。那它住哪儿?笔者卖个关子,后面 g++ 真身的部分,您亲眼就能看到。

另一处在被调用符号的尾巴上,那里挂了个 @PLT 后缀。这个后缀和动态库的调用方式有关,和 PLT 配套的还有一个 GOT:PLT 是函数调用走的跳板机制,GOT 是它查地址用的表。您现在看不懂完全正常,讲位置无关与 GOT/PLT 的那篇,就是专门为它们准备的。

至于编译器的内部,从语法分析、优化到指令选择的每一层,都够咱们讲一整篇。编译器那篇不钻这些层的算法,看的是另一头:您写的源码进去,出来的汇编在哪儿被它动了手。

汇编:文字变二进制 ​

轮到第三个开关 -c 了:咱们让 g++ 在生成目标文件之后停。

bash
g++ -c hello.cpp -o hello.o
text
hello.o:   ELF 64-bit LSB relocatable, x86-64, version 1 (SYSV), not stripped

到了这一步,产物就不再是给人看的了。file 说它是一个 ELF 64-bit 的 relocatable 文件。ELF 的全称是 Executable and Linkable Format,翻译过来就是可执行可链接的格式,Linux 上的目标文件和可执行文件,用的都是这套容器,咱们到目标文件解剖和番外那两篇里还得跟它反复打交道。relocatable 的意思是可重定位:文件里的地址都还是临时的,得等链接阶段来安排它们的去处。汇编器干的活非常机械,拿着咱们的 hello.s,一条一条翻成了机器码,再按 ELF 的格式打包起来,咱们平时挂在嘴边的 .o 文件就是这么来的。

输出里还有一个词值得咱们高兴:not stripped,符号信息都留下来了。这对咱们是天大的好消息,以后拿 nm、objdump 之类的工具解剖目标文件,全指着它留下的符号表。它就是目标文件解剖那篇的主角,咱们到时候带着工具,把这个 hello.o 从里到外地看个遍。

链接:目标文件变可执行文件 ​

到了链接这一步,咱们拿上一阶段的 hello.o 当原料:

bash
g++ hello.o -o hello_app
text
hello_app: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2

您拿这行输出和 hello.o 那行比一比,能挑出来的差别可不少。它的格式倒还是 ELF,身份却从 relocatable 变成了 pie executable。pie 是位置无关的意思,里面的讲究,位置无关那篇会给咱们答案。反正它现在已经是一个真正能跑的程序了。后面跟着的 dynamically linked,说明它跑起来的时候要依赖动态库。末尾还多出了一位叫 interpreter 的新面孔,后面挂着一串长长的路径。

interpreter 的身份,咱们现在揭晓:它就是动态链接器。咱们的程序用到了 libstdc++ 这些动态库,操作系统把它装起来跑的时候,得靠 interpreter 把要用的库一个个找来、接好。从程序的加载,到 main 执行的第一行,中间还有一整套的流程,那是程序启动那篇的内容。

链接到底往程序里塞了多少东西,咱们还有一个更直观的办法:size 命令。

text
$ size hello.o hello_app
   text	   data	    bss	    dec	    hex	filename
    156	      0	      0	    156	     9c	hello.o
   1708	    632	    280	   2620	    a3c	hello_app

咱们补一句名词:text 是代码段,data 放的是已初始化的全局数据,bss 放的是未初始化的全局数据,dec 和 hex 是前三列加起来的十进制与十六进制。

咱们再看数字。hello.o 的那一行,text 占了 156,data 和 bss 都是干净的 0,毕竟咱们只写了六行代码。hello_app 呢?text 涨到了 1708,data 和 bss 也从无变成了有。多出来的是谁?咱们的代码可没有变多,多出来的部分,是别的目标文件和运行时的启动代码,在链接这一步被合了进来。它们是谁放进来的?您别急,下一节您就能自己看到答案。

g++ 本人并不是编译器 ​

四个阶段都亲手跑过了,现在咱们揭个底:g++ 从头到尾都没当过编译器。

咱们给 g++ 挂上 -v,再完整地编译一次,让它把幕后的动作交代出来:

bash
g++ -v hello.cpp -o hello_v

输出的篇幅相当长,笔者把和主线无关的部分删掉了,真正在干活的只有三条命令。省略号是笔者加的,被省掉的参数还有很多:

text
 /usr/lib/gcc/x86_64-pc-linux-gnu/16/cc1plus -quiet ... -o /tmp/ccC9eT4s.s
 as -v --64 -o /tmp/ccRhctwc.o /tmp/ccC9eT4s.s
 /usr/lib/gcc/x86_64-pc-linux-gnu/16/collect2 ... -o hello_v ... crt*.o ... /tmp/ccRhctwc.o -lstdc++ -lm -lgcc_s ...

咱们看打头的 cc1plus,它才是真正的编译器。有个细节很有意思:咱们讲的预处理和编译两个阶段,它一个程序全包了。所以咱们说的四个阶段,是咱们观察用的逻辑划分,方便咱们中途拦停、取出中间产物。真实工具的分段跟它并不一一对应。咱们前面用的 -E、-S、-c,干的就是这个活:让 g++ 干到某一段就收工,把中间的产物留下来。

中间的 as 是出身 binutils 的汇编器,干的活就是把 .s 翻成 .o。压轴的 collect2 是链接器 ld 的包装,好东西都压在了这一行里,咱们把它放大了看。

里面塞着一批咱们从来没开口要过的东西:Scrt1.o、crti.o、crtbeginS.o、crtendS.o、crtn.o,它们是一批 C 运行时的启动文件。collect2 还自作主张带上了一排默认库,咱们从来没写过的 -lstdc++、-lm、-lgcc_s 和 -lc,全都在里面了。咱们没写一行启动代码,它们自己来了。启动文件在 main 之前干了什么,和 interpreter 是一条路上的,咱们留给程序启动那篇。而 operator<< 的实现,就住在 -lstdc++ 指向的库里,前面卖的关子,答案就是它了。现在您也能解释 size 的输出对比了:咱们指定过的只有 hello.o,collect2 却把启动文件静态合了进来,text、data、bss 涨出来的部分,就是它们的贡献。那排默认库就不一样了,它们是以动态依赖的方式挂上的,它们的代码不会进到这个文件里,动态库到底是怎么挂的,咱们留给动态库总览那篇。

咱们聊到这儿,g++ 的身份就清楚了:它其实是个驱动程序(driver)。咱们平时说的“编译一下”,背后的实际过程,是 g++ 按着顺序把 cc1plus、as、collect2 请了出来,把上一步的输出递给下一步,再把咱们传的参数翻译成各自认识的形式。所以严格来说,咱们今天从头到尾都没直接碰过编译器,一直是 g++ 在替咱们跑腿。

这一卷的十六篇 ​

今天咱们把四个阶段各摸了一下,剩下的十五篇,大致就是把它们放大了讲:

  • 编译段管的是 02 到 05:02 预处理、03 编译器做了什么、04 目标文件解剖,还有 05 链接器。今天咱们只看了每一段的产物,内部的展开就交给它们。
  • 复用段说的是 06 和 07:一篇打包静态库,另一篇收拾的是模板、inline 与 ODR(单一定义规则,One Definition Rule)。咱们写的代码怎么打包给别人复用?同一个定义怎么做到不重复?答案就放在这两篇里了。
  • 动态库工程段是最长的一段,从 08 的动态库总览,一路铺到 13 的运行时加载与插件:09 讲的是位置无关与 GOT/PLT(GOT 的全称是全局偏移表,Global Offset Table),10 讲的是库搜索逻辑,11 讲的是符号可见性,12 讲的则是 ABI(二进制接口,Application Binary Interface)设计。今天轻轻碰到的 dynamically linked 和 @PLT,背后的机制,咱们都要在这一段里展开。
  • 进阶段收尾:14 程序的启动、15 LTO(链接时优化,Link Time Optimization)与现代链接器,再加上 16 的番外。番外聊的是一个好玩的问题:动态库,能不能当成可执行文件直接跑?咱们今天只是远远望了一眼 interpreter,main 之前的整个流程,都归程序启动那篇了。

构建系统的视角 ​

您日常大概不直接敲 g++,而是在 CMake 工程里构建。其实没关系,构建系统可以把它实际执行的命令原样摆给咱们看:

bash
cmake --build build --verbose

咱们加上 --verbose,构建时跑的每一条真实命令都会打出来:每个源文件都有它的一条编译命令,收尾的则是一条链接命令。咱们今天手工敲的和它跑的,其实是同一类东西,区别只在路径的长度和参数的数量。

所以构建系统没什么魔法:它不亲自编译,它替咱们把四个阶段排好队,把成百个源文件的编译排成并行,再把路径、宏定义、链接选项一一填对了。至于 CMake 本身的用法,是卷七(工程实践)的地盘。咱们在这里只确认一件事:您每天构建时跑的,就是今天的这四段。

回到日常:undefined reference 发生在哪 ​

最后咱们回到一个您最熟的时刻:改了一点代码,把构建命令敲了下去,满屏刷的都是 undefined reference,程序也就编不出来了。

现在您可以自己推一推,这报错到底出在哪一段?预处理是不背这个锅的,它做的只是文本替换。编译器其实也不管,咱们今天在汇编里亲眼看到了,hello.cpp 调用的 operator<< 压根不在本文件里定义,编译器照样心平气和地生成了 call 指令。翻译单个文件的时候,用到别处定义的东西是正常操作,编译器只负责把这个引用如实地登记下来。

真正的关口在链接。链接器要拿着每一条这样的引用,去所有的 .o 和库里找实现:找得到的就接上,找不到的,您就收到了 undefined reference。咱们的 hello_app 为什么没报错?operator<< 的实现在 libstdc++ 里,而 collect2 默认就带上了 -lstdc++,名字对上了,链接也就过了。

那要是链接了库还是找不到?链接器按什么顺序找库?静态库和动态库谁排前面?明明存在的库,为什么它还是说找不到?这些是链接器那篇和库搜索那篇的内容,咱们到时候一个场景一个场景过。

咱们下一篇就从 hello.i 那四万四千九百七十一行开始,回去看预处理的那一步,到底都做了些什么。

v0.13.0-17-gf6158c6 · f6158c6 · 2026-11-20