第1章：从源码到可执行文件：编译四阶段全景

从位与字节出发，把"源码变成可执行文件"这条流水线的四个阶段逐一拆开，再追到运行时与操作系统——先把整张地图画清楚

1.1 零基础铺垫：从位到程序

用第一性原理问一个问题：一段程序，归根结底是什么？答案朴素得惊人——程序就是一堆 0 和 1。机器（CPU）只认二进制，它不认识"Hello"也不认识 int，只认识两种电压状态：有电（记作 1）、没电（记作 0）。这个最小的信息单位叫位（bit，比特），是计算机世界的原子。一个位太孤单，计算机把 8 个位组织成一组，称为一个字节（byte，1 字节 = 8 位），字节才是计算机处理信息的基本单位。

那文字是怎么变成字节的？靠一张"翻译表"。大部分操作系统使用 ASCII 标准来表示文本字符：每个字符被映射成一个唯一的、恰好一字节大小的整数值。比如大写字母 A 对应十进制 65（二进制 01000001），换行符 \n 对应十进制 10。说人话：你写的每一行源码，在磁盘上就是一组按 ASCII 编码的字节序列——所谓"源程序"，本质上就是一个字节序列，仅此而已。下面这个程序就是本书的常驻主角，先混个脸熟：

// hello.c —— 本章的"解剖样本"
#include <stdio.h>   // 预处理指令：把标准输入输出头文件"粘贴"进来

int main(int argc, char* argv[])   // 程序入口函数
{
    printf("%d\n", 1111);   // 向屏幕输出数字 1111
}

眼见为实——用十六进制转储工具 hexdump（十六进制查看器，逐字节显示文件内容）看看这个源码文件在磁盘上的真实样子。你会看到第一行 #include 的每个字符都对应一个字节：23 是 #，69 是 i，6e 是 n……右侧的 ASCII 列就是这些字节还原出来的文字：

# hexdump -C：以十六进制 + ASCII 双栏显示文件字节
hexdump -C hello.c
# 输出（真实转储，节选）：
00000000  23 69 6e 63 6c 75 64 65  20 3c 73 74 64 69 6f 2e  |#include <stdio.|
00000010  68 3e 0a 69 6e 74 20 6d  61 69 6e 28 69 6e 74 20  |h>.int main(int |
00000020  61 72 67 63 2c 20 63 68  61 72 2a 20 61 72 67 76  |argc, char* argv|

1.2 编译四阶段：预处理 / 编译 / 汇编 / 链接

为了在系统上运行 hello.c，这条源码必须被其他程序转换成一系列低级机器语言指令（CPU 直接执行的指令），然后这些指令按照一种称为可执行目标程序的格式打包好，以二进制磁盘文件的形式存放。在 Unix 系统上，这个转换由编译器驱动程序完成——对 C 是 gcc，对 C++ 是 g++。一条 gcc -o hello hello.c 背后，其实藏着四个独立程序在接力，它们合起来构成编译系统（compilation system）：

阶段一：预处理（preprocessing）。由预处理器（cpp）执行，它处理所有以 # 开头的命令：#include 指令让它读取系统头文件（如 stdio.h）的内容并直接插入程序文本，#define 指令让它做文本替换。产物是另一个 C/C++ 程序，通常以 .i 为扩展名。阶段二：编译（compilation）。由编译器（GCC 内部叫 cc1）把 hello.i 翻译成 hello.s——一个汇编语言程序，每条语句以标准文本格式精确描述一条低级机器指令。阶段三：汇编（assembly）。由汇编器（as）把 hello.s 翻译成机器语言指令，打包成可重定位目标程序格式，存为 hello.o——这是一个二进制文件，用文本编辑器打开只会看到乱码。阶段四：链接（linking）。我们的程序调用了 printf，它存在于一个单独预编译好的 printf.o 目标文件中，链接器（ld）负责把它并入 hello.o，最终得到可执行文件 hello。四个阶段对应四条真实命令：

# 阶段一：预处理 —— 展开 #include / #define，产出 hello.i
gcc -E hello.c -o hello.i

# 阶段二：编译 —— 把 C 源码翻译成汇编语言，产出 hello.s
gcc -S hello.i -o hello.s

# 阶段三：汇编 —— 把汇编翻译成机器码目标文件，产出 hello.o
gcc -c hello.s -o hello.o

# 阶段四：链接 —— 把 hello.o 与 printf.o 等拼装成可执行文件
gcc hello.o -o hello

# 一条命令等价于以上四步（编译器驱动程序内部自动完成）
gcc -o hello hello.c

每个阶段都有看得见摸得着的产物。预处理后的 hello.i 不再只有 5 行——stdio.h 的内容全被"灌"了进来。文件开头那串 # 行号 "文件名" 的行标记（linemarkers）是预处理器留下的路标，告诉后续阶段"这段代码来自哪个文件的第几行"，方便报错定位。下面是真实的 hello.i 开头（头文件的绝对路径随系统不同而异）：

# gcc -E hello.c -o hello.i 之后，文件开头长这样（真实输出节选）：
# 1 "hello.c"
# 1 "<built-in>" 1
# 1 "<command line>" 1
# 1 "hello.c" 2
# 1 "/usr/include/stdio.h" 1 3 4
# 61 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/_stdio.h" 1 3 4
# 69 "/usr/include/_stdio.h" 3 4
...（中间是 stdio.h 展开出的几百行声明）...
# 2 "hello.c" 2
int main(int argc, char* argv[])
{
    printf("%d\n", 1111);
}

编译阶段的产物 hello.s 是汇编语言——它比 C 更接近机器，但仍然是文本，人能读懂。比如 main 函数的开头几条指令：pushq 把旧栈帧基址压栈保存，movq 设置新栈帧，movl 把参数搬到寄存器（x86-64 架构上，函数前几个参数放在 %edi、%esi 等寄存器里），addl 做加法，ret 返回。真实的汇编输出形如（不同编译器/架构细节略有差异）：

# gcc -S hello.i -o hello.s 之后，main 函数的汇编（真实格式，x86-64）：
        .globl  main
main:
        pushq   %rbp
        movq    %rsp, %rbp
        movl    %edi, -4(%rbp)
        movl    %esi, -8(%rbp)
        movl    $1111, %esi
        leaq    L_.str(%rip), %rdi
        callq   _printf
        xorl    %eax, %eax
        popq    %rbp
        retq

阶段	执行程序	命令	产物	产物性质
预处理	预处理器（cpp）	gcc -E hello.c -o hello.i	hello.i	文本（头文件已展开）
编译	编译器（cc1）	gcc -S hello.i -o hello.s	hello.s	文本（汇编语言）
汇编	汇编器（as）	gcc -c hello.s -o hello.o	hello.o	二进制（机器指令）
链接	链接器（ld）	gcc hello.o -o hello	hello	二进制（可执行文件）

最后强调一个实用细节：C++ 的编译过程同理，只是驱动命令从 gcc 换成 g++，上面分步编译的命令完全适用（g++ -E / -S / -c 照用不误）。区别在于：g++ 会自动链接 C++ 标准库，而 gcc 不会——第 2 章实操时你会亲眼看到这个差别。

1.3 为什么程序员要理解编译系统

现代编译器都是成熟的工具，通常能生成很好的代码——多数时候你无需为了写出高效代码而深入编译器内部。但为了在程序里做出好的代码选择，你确实需要懂一点"编译器会把我的代码变成什么"。这是理解编译系统的第一个好处：优化程序性能。比如：一个 switch 语句是不是总比一串 if-else 高效？一次函数调用到底要付出多大代价？while 循环比 do-while 更高效吗？指针引用比数组引用更高效吗？这些问题的答案都藏在"编译器如何把 C/C++ 语句翻译成汇编"里——不懂汇编，你只能靠猜；懂了，你就能在性能敏感处做出有依据的选择。

第二个好处：理解链接时出现的错误。根据经验，一些最令人困扰的程序错误往往与链接器有关，尤其是构建大型软件系统时。链接器报告"无法解析一个引用"是什么意思？静态变量和全局变量的区别是什么？静态库和动态库的区别是什么？-l、-L 这些神秘参数在做什么？这些问题的答案都在链接器的工作方式里——第 4、5 章的主战场。

第三个好处：避免安全漏洞。近年来，缓冲区溢出（buffer overflow，向固定大小的内存区域写入超出容量的数据，导致相邻内存被覆盖）错误造成了大多数网络和 Internet 服务器上的安全漏洞。这些错误的存在，是因为大多数程序员忽视了"编译器用来为函数产生代码的堆栈规则"。理解栈的组织方式，你就知道为什么 strcpy 这类函数是危险的、为什么编译器会发出警告——下面这个 8 字节的缓冲区硬塞 36 个字符的例子，编译器直接亮起了红灯（真实警告）：

// overflow.cpp —— 经典缓冲区溢出示例
#include <cstring>
#include <cstdio>

int main() {
    char buf[8];                          // 只有 8 字节的小缓冲区
    strcpy(buf, "this string is way too long");  // 硬塞 28 个字符
    printf("%s\n", buf);
    return 0;
}

# 编译（真实警告，GCC 15）：
g++ overflow.cpp -o overflow
# warning: 'void* __builtin_memcpy(void*, const void*, long unsigned int)'
#   writing 28 bytes into a region of size 8 overflows the destination
#   [-Wstringop-overflow=]
#     5 |     strcpy(buf, "this string is way too long");

1.4 程序运行时发生了什么

编译结束了，可执行文件 hello 躺在磁盘上。当你在终端敲下 ./hello，系统里发生了什么？要回答这个问题，先认识一台典型计算机的硬件组织。它由四类部件构成：总线（bus，贯穿系统的一组电子管道，负责在部件间搬运信息字节）、I/O 设备（input/output，输入输出设备，系统与外界的联系通道，如键盘、鼠标、显示器、磁盘）、主存（main memory，临时存储设备，程序运行时用来存放程序和程序处理的数据）、处理器（CPU，中央处理单元，解释并执行主存中指令的引擎）。

几个关键部件说人话：总线被设计成传送定长的字节块，这个定长叫字（word），字长是基本系统参数——x86-64 系统的字长是 8 字节（64 位），小型嵌入式控制器往往只有 1 或 2 字节。主存物理上由 DRAM（动态随机存储器，一种靠电容存电来保存数据的芯片）组成，逻辑上是一个线性的字节数组，每个字节有唯一地址（数组下标），从 0 开始。CPU 的核心是一个叫程序计数器（PC，program counter）的寄存器，它永远指向主存中"下一条要执行的机器指令"。CPU 从通电到断电，一直重复同一件基本任务：从 PC 指向的地址取指令 → 解释指令中的位 → 执行指令指示的简单操作 → 更新 PC 指向下一条指令。这些简单操作在主存、寄存器文件和 ALU（算术/逻辑单元，负责计算新数据和地址值）之间循环。

# CPU 的"无限循环"（第一性原理视角）
while (系统通电) {
    取指令：从 PC 指向的主存地址读取一条机器指令;
    译指令：解释这条指令的二进制位是什么意思;
    执行：  在主存 / 寄存器文件 / ALU 之间完成简单操作;
    更新：  PC 指向下一条指令（不一定是相邻的那条）;
}

# ./hello 的三幕旅程：把信息从一处搬到另一处
# 第一幕：shell 读取命令（逐字符读入 ./hello）
键盘 --输入--> 寄存器 --存储--> 主存
# 第二幕：加载程序——DMA 直通，不经过 CPU
磁盘(hello 可执行文件) --DMA--> 主存
# 第三幕：执行——取指 / 译码 / 执行循环
主存 --> CPU --> 显示设备   # 输出 "1111"
@DMA 是磁盘到主存的直接通道：CPU 不参与搬运，只负责发号施令

现在串起 ./hello 的完整旅程。第一幕：shell 读取命令。shell（外壳程序，就是你敲命令的那个终端程序）等待我们输入命令，当你敲入 ./hello，它逐字符把输入读进寄存器、再存入主存。第二幕：加载程序。回车后，shell 执行一系列指令，把 hello 文件中的代码和数据从磁盘拷贝到主存——利用 DMA（direct memory access，直接存储器存取）技术，数据可以不经过处理器，直接从磁盘到达主存。第三幕：执行。一旦代码和数据加载完毕，CPU 开始执行 main 的机器指令，把 "1111\n" 这些字节从主存拷贝到寄存器，再从寄存器拷贝到显示设备，最终显示在屏幕上。这个过程揭示了一课：系统花了大量时间把信息从一个地方搬到另一个地方——磁盘 → 主存 → CPU → 显示设备。所以系统设计者的首要目标，就是让这些拷贝尽可能快，由此诞生了存储器层次结构：

层级	速度	容量	成本	说人话
寄存器（CPU 内）	最快（纳秒级）	几十~几百字节	最贵	CPU 手里的草稿纸
高速缓存（Cache）	极快	几 MB	很贵	主存的"常用抽屉"
主存（DRAM）	快	几 GB~几十 GB	中等	程序运行的大本营
磁盘（SSD/HDD）	慢（毫秒级）	几百 GB~几 TB	便宜	长期仓库

1.5 操作系统：进程 / 虚拟存储器 / 文件的抽象

注意一个细节：当 shell 加载运行 hello、hello 输出消息时，程序从头到尾都没有直接访问键盘、显示器、磁盘或主存——它靠的是操作系统提供的服务。操作系统（OS，operating system）是插在应用程序和硬件之间的一层软件，所有应用程序对硬件的操作都必须经过它。它有两个基本功能：防止硬件被失控的应用程序滥用（比如禁止你的程序乱写别人的内存、霸占 CPU 不放）；为应用程序提供简单一致的方法来控制复杂又千差万别的低级硬件（你不需要知道磁盘的磁头怎么动，只需调用"写文件"）。

操作系统通过三个基本抽象实现这两个功能：文件（file）、虚拟存储器（virtual memory）、进程（process）。文件：对 I/O 设备的抽象表示。文件只不过就是字节序列，每个 I/O 设备——磁盘、键盘、显示器，甚至网络——都可以被看成文件。系统中所有输入输出，都通过称为 Unix I/O 的一小组系统函数调用读写文件来实现。虚拟存储器：对主存和磁盘 I/O 设备的抽象表示。它为每个进程提供一个假象：好像每个进程都在独占地使用主存。每个进程看到的存储器都是一致的，称为虚拟地址空间（virtual address space）。进程：对处理器、主存和 I/O 设备的抽象表示——它是"正在运行的程序"的化身，是操作系统管理 CPU 时间的基本单位。

Linux 进程的虚拟地址空间（其他 Unix 系统设计类似）自下而上分为几个区。最上面约四分之一预留给操作系统内核的代码和数据（对所有进程都一样），底部四分之三存放用户进程的代码和数据。从上到下依次是：内核虚拟存储器（顶部预留区，应用程序禁止读写）、用户栈（编译器用来实现函数调用，每次调用函数栈就增长、返回就收缩）、共享库（如 C 标准库这种被多个进程共用的代码和数据）、堆（随 malloc/free 调用在运行时动态扩展收缩）、程序代码和数据（从固定地址开始，由可执行目标文件直接初始化）：

# Linux 进程虚拟地址空间布局（地址从下往上增大）
0xFFFFFFFF  ┌──────────────────────┐
            │  内核虚拟存储器      │  ← 顶部 1/4，用户不可读写
            ├──────────────────────┤
            │  用户栈（向下生长）  │  ← 函数调用在此压栈/弹栈
            │          ↓           │
            │          ↑           │
            ├──────────────────────┤
            │  共享库              │  ← libc、libstdc++ 等
            ├──────────────────────┤
            │  堆（向上生长）      │  ← malloc/new 在这里分配
            │          ↑           │
            ├──────────────────────┤
            │  程序代码和数据      │  ← 可执行文件加载进来
0x00000000  └──────────────────────┘

# 验证"文件即字节序列"：标准库函数背后都是 Unix I/O 系统调用
#include <cstdio>

int main() {
    FILE* fp = fopen("hello.txt", "w");   // 打开一个文件
    fprintf(fp, "hello\n");              // 写入字节序列
    fclose(fp);                          // 关闭文件
    return 0;
}