序 · 开始之前§ 0.1
程序是怎么跑起来的:源代码、编译器与可执行文件
程序员写的是文字,处理器只认识数字。本章把一个 6 行的 C++ 程序从头跟到尾:预处理把它变成 8 万多行,编译变成汇编,汇编变成机器码,链接把缺的地址填上,最后操作系统让它在屏幕上打出一行字。
你在电脑上双击一个图标,一个程序就运行起来了。这个程序是怎么来的?
程序员写程序,写的是文字,和写一篇文章差不多。而电脑里真正干活的处理器(CPU)只认识一串一串的数字。从文字到数字,中间有一位“翻译”,叫编译器。
这一章我们跟着一个只有 6 行的 C++ 程序,看它怎样一步一步变成处理器能执行的数字,最后在屏幕上打出一行字。
这是几乎所有 C++ 教程的第一个程序:
#include <iostream>
int main() { std::cout << "Hello, world!\n"; return 0;}$ ./hello
Hello, world!
上面是代码,下面是运行它之后屏幕上出现的内容。$ ./hello 表示“运行名叫 hello 的程序”,下一行就是它的输出。
逐行看一下,现在知道个大概就够了,后面的章节会一个一个细讲:
| 代码 | 意思 |
|---|---|
#include <iostream> |
把“输入输出”的工具拿过来用。iostream 是 input/output stream(输入输出流)的缩写 |
int main() { |
程序从这里开始执行。每个 C++ 程序都必须有一个叫 main 的部分 |
std::cout << "Hello, world!\n"; |
把双引号里的文字输出到屏幕。\n 表示换行,句末的分号表示这一句结束 |
return 0; |
main 结束,并告诉操作系统“一切正常” |
} |
和第 3 行的 { 配对,表示 main 到这里为止 |
处理器只认识数字
Section titled “处理器只认识数字”处理器能做的事情其实很简单:从内存里取一个数,加上另一个数,比较两个数的大小,跳到别的地方继续执行……每件事叫一条指令。每条指令都编成一个数字,这些数字叫机器码。
上面那个程序的 main,翻译成这台电脑(苹果 M 系列芯片,ARM 架构)的机器码,是下面这 11 个数字。每个数字用十六进制写出来,占 4 个字节:
a9bf7bfd 910003fd 90000020 f9401800 90000001 91282021 528001c2 94000004 52800000 a8c17bfd d65f03c0
一共 44 个字节。没人能直接写这种东西,所以我们写 C++,让编译器去翻译。
从源代码到可执行文件
Section titled “从源代码到可执行文件”我们写的文字叫源代码,存在 hello.cpp 这样的文件里(.cpp 是 C++ 源代码的扩展名)。处理器能运行的文件叫可执行文件。从源代码到可执行文件,要经过四步:
- 预处理:处理所有以
#开头的行,比如把#include换成被引入文件的内容 - 编译:把 C++ 翻译成汇编,也就是机器指令的文字写法
- 汇编:把汇编变成机器码,得到目标文件(
.o) - 链接:把目标文件和别人写好的代码(比如标准库)接在一起,得到可执行文件
平时一条命令就把四步全做完了,中间文件也不会留下来。为了看清楚,下面的图把每一步的产物都保存了下来:
人写的文字:一个普通的文本文件,6 行、86 个字节。电脑的处理器(CPU)看不懂它。
#include <iostream>
int main() {
std::cout << "Hello, world!\n";
return 0;
}第一行 #include <iostream> 的意思是"把输入输出的工具拿过来用"。下一步会看到它实际拿来了多少东西。
预处理把 #include <iostream> 这一行,原样替换成头文件 iostream 的全部内容;iostream 又引入了别的头文件,一共988 个。6 行变成了 84,254 行(3.6 MB),我们自己写的代码在最后。
namespace __attribute__((__type_visibility__("default"))) std { inline namespace __1 {
template <class _Tp>
class allocator;
template <class _Tp>
class shared_ptr;
} }
……(中间省略 84,242 行)……
int main() {
std::cout << "Hello, world!\n";
return 0;
}编译把 C++ 翻译成汇编:处理器指令的文字写法,一行一条。整个文件 571 行,大部分是 iostream 里被用到的函数;我们的 main 只有下面 11 条。
| stp x29, x30, [sp, #-16]! | 进入函数时的固定动作:保存现场 |
| mov x29, sp | |
| adrp x0, __ZNSt3__14coutE@GOTPAGE | 找到 std::cout |
| ldr x0, [x0, __ZNSt3__14coutE@GOTPAGEOFF] | 找到 std::cout |
| adrp x1, l_.str@PAGE | 找到字符串 "Hello, world!\n" |
| add x1, x1, l_.str@PAGEOFF | 找到字符串 "Hello, world!\n" |
| mov w2, #14 | 14 = "Hello, world!\n" 的长度 |
| bl __ZNSt3__124__put_character_sequenceB9nqe… | 调用标准库里负责输出的函数 |
| mov w0, #0 | return 0 |
| ldp x29, x30, [sp], #16 | 恢复现场 |
| ret | 返回:main 结束 |
汇编把每条指令变成机器码:处理器真正执行的数字。这台机器上每条指令正好 4 个字节,main 一共 44 个字节。有几个地方填的是 0:要用的东西在别的文件里,现在还不知道地址。
| 位置 | 机器码 | 对应的指令 | |
|---|---|---|---|
| 0 | a9bf7bfd | stp x29, x30, [sp, #-0x10]! | 进入函数时的固定动作:保存现场 |
| 4 | 910003fd | mov x29, sp | |
| 8 | 90000000 | adrp x0, 0x0 | 地址还不知道,先填 0 |
| c | f9400000 | ldr x0, [x0] | 地址还不知道,先填 0 |
| 10 | 90000001 | adrp x1, 0x0 | 地址还不知道,先填 0 |
| 14 | 91000021 | add x1, x1, #0x0 | 地址还不知道,先填 0 |
| 18 | 528001c2 | mov w2, #0xe | 14 = "Hello, world!\n" 的长度 |
| 1c | 94000000 | bl 0x1c | 调用输出函数,但它在哪里还不知道:先填 0 |
| 20 | 52800000 | mov w0, #0x0 | return 0 |
| 24 | a8c17bfd | ldp x29, x30, [sp], #0x10 | 恢复现场 |
| 28 | d65f03c0 | ret | 返回:main 结束 |
hello.o 一共 4,224 字节。它自己定义了 16 个函数和数据,还缺 24 个要从别处找,比如 std::cout。
链接把 hello.o 和标准库接在一起,把那些 0 换成真正的地址,得到可以运行的程序:35,912 字节(35.1 KB)。其中真正的机器码只有 988 字节,89% 的字节是为了按 16 KB 一页对齐而填的 0。
| 位置 | 机器码 | 对应的指令 | |
|---|---|---|---|
| 1000004e8 | a9bf7bfd | stp x29, x30, [sp, #-0x10]! | |
| 1000004ec | 910003fd | mov x29, sp | |
| 1000004f0 | 90000020 | adrp x0, 0x100004000 | 地址填好了 |
| 1000004f4 | f9401800 | ldr x0, [x0, #0x30] | 地址填好了 |
| 1000004f8 | 90000001 | adrp x1, 0x100000000 | 也填好了:这里存的是相对距离,恰好是 0 |
| 1000004fc | 91282021 | add x1, x1, #0xa08 | 地址填好了 |
| 100000500 | 528001c2 | mov w2, #0xe | |
| 100000504 | 94000004 | bl 0x100000514 | 链接器填好了:往后跳 4 条指令 |
| 100000508 | 52800000 | mov w0, #0x0 | |
| 10000050c | a8c17bfd | ldp x29, x30, [sp], #0x10 | |
| 100000510 | d65f03c0 | ret |
标准库的大部分并没有复制进来,而是运行时再去找:这个程序还依赖 libc++.1.dylib 和 libSystem.B.dylib。文件类型:Mach-O 64-bit executable arm64,也就是只能在 64 位 ARM 处理器的 macOS 上运行。
操作系统把 hello 读进内存,从 main 的第一条指令开始执行。main 返回的 0 交还给操作系统,表示"正常结束"。
$ ./hello Hello, world! $ echo $? 0
图里有几个值得停下来看的地方。
6 行变成了 8 万多行
Section titled “6 行变成了 8 万多行”#include <iostream> 不是“引用”一下,而是把 iostream 这个文件的内容原样复制进来。iostream 自己又 include 了别的文件,一层套一层,一共引入了 988 个文件。预处理之后的 hello.ii 有 84,254 行、3.6 MB,我们写的 6 行在最末尾。
这也是 C++ 编译比较慢的一个原因:每个 .cpp 文件都要把它引入的头文件从头读一遍。第 6.1 节会再讲到。
机器码里有几个 0
Section titled “机器码里有几个 0”编译出的 hello.o 里,main 要做的事情已经全部变成了机器码,但有几处填的是 0。比如那条 bl(branch with link,跳过去执行一个函数,执行完再回来):真正负责输出文字的函数在标准库里,hello.o 并不知道它在哪里,只好先填 0,并在文件里记下一笔“这里要填某某函数的地址”。
hello.o 自己定义了 16 个函数和数据,还缺 24 个要从别处找,std::cout 就是其中之一。
链接把地址填好
Section titled “链接把地址填好”链接器把 hello.o 和标准库放在一起,把每个“先填 0”的地方换成真正的地址。对比图中第 4 步和第 5 步,同一条 bl 指令的机器码从 94000000 变成了 94000004。
得到的可执行文件有 35,912 字节,而源代码只有 86 字节。不过这 35,912 字节里,有 89% 是 0:macOS 在 ARM 芯片上按 16 KB 一页来安排程序的各个部分,一部分哪怕只有几百字节,在文件里也要占满一页。真正的机器码只有 988 字节,其中 main 占 44 字节,其余是用到的几个 iostream 函数。
标准库的大部分并没有复制进来,而是程序运行时再去系统里找,这叫动态链接。
运行:操作系统接手
Section titled “运行:操作系统接手”在命令行里输入 ./hello,操作系统会:
- 把
hello文件读进内存 - 找到用到的标准库,也装进内存,把地址接好
- 从
main的第一条指令开始执行
main 最后的 return 0 把 0 交给操作系统,这个数叫退出码。0 表示正常结束,其他数一般表示出了某种问题。在命令行里用 echo $? 可以看到上一个程序的退出码。把 return 0 改成 return 3 试试:
#include <iostream>
int main() { std::cout << "Hello, world!\n"; return 3;}$ ./exit3 Hello, world! $ echo $? 3
屏幕上的输出一样,但退出码变成了 3。用户平时看不到退出码,它是给别的程序看的:比如一个自动化脚本可以根据它判断上一步是否成功。
编译出的程序只能在一种电脑上运行
Section titled “编译出的程序只能在一种电脑上运行”本章的可执行文件,用 file 命令查看是:
Mach-O 64-bit executable arm64
意思是:macOS 的程序格式(Mach-O),给 64 位 ARM 处理器用的。机器码是写给某一种处理器的,程序的包装格式是写给某一种操作系统的。拿到 Windows 电脑上,它既看不懂这种格式,大多数 Windows 电脑的处理器(x86-64)也不认识 ARM 的机器码。
能“到处用”的是源代码:同一份 hello.cpp,在 Windows 上用那里的编译器重新编译一遍,就能得到 Windows 上的可执行文件。
和 Python 比一比
Section titled “和 Python 比一比”如果你听说过 Python,它的程序不需要先编译。运行 Python 程序时,一个叫解释器的程序一边读源代码,一边执行。
| C++(编译型) | Python(解释型) | |
|---|---|---|
| 什么时候翻译 | 运行之前,一次翻译完 | 每次运行时,边读边执行 |
| 发给别人的是 | 可执行文件 | 源代码,对方要装好解释器 |
| 拼写错误什么时候发现 | 大多在编译时 | 运行到那一行时 |
| 运行速度 | 通常快得多 | 通常慢一些 |
C++ 的代价是每次改完代码都要重新编译;好处是很多错误在程序运行之前就被发现了,而且翻译好的机器码可以直接交给处理器,不需要边读边翻译。
| 误解 | 实际 |
|---|---|
改了 hello.cpp,运行 ./hello 就是新的 |
可执行文件是上次编译的结果,不重新编译,运行的还是旧版本 |
| 可执行文件的大小就是代码的多少 | 本章的可执行文件有 35,912 字节,真正的机器码只有 988 字节,大部分是为了按页对齐而填的 0 |
| 报错都是“编译错误” | 有的错在编译时发现,有的到链接时才发现(见练习 4),有的要运行起来才出现。0.3 节专门讲怎么读报错 |
return 0 是给用户看的 |
它是给操作系统和其他程序看的,屏幕上不会显示 |
- 处理器只认识机器码。我们写源代码,由编译器翻译成机器码
- 翻译分四步:预处理、编译、汇编、链接。平时一条命令全部做完
#include会把整个头文件复制进来:6 行的程序预处理后有 84,254 行- 目标文件里,“在别处定义的东西”的地址先填 0,链接时才填上
- 程序从
main开始执行,main返回的数是退出码,0 表示正常 - 可执行文件只能在一种处理器 + 操作系统上运行,源代码可以在别处重新编译
你编译好了 hello,然后把 hello.cpp 里的 Hello, world! 改成了 Hi!,保存,但没有重新编译,直接运行 ./hello。屏幕上会显示什么?
查看答案
还是 Hello, world!。./hello 运行的是可执行文件,它是上次编译时生成的,和现在的 hello.cpp 已经没有关系了。改完源代码,要重新编译一次,可执行文件才会更新。
把 main 里的 return 0; 改成 return 3;,运行后再执行 echo $?。会看到什么?屏幕上的 Hello, world! 还会出现吗?
查看答案
Hello, world! 照常出现,echo $? 显示 3。退出码只是 main 交给操作系统的一个数,不影响程序前面做的事情。实际运行的结果见正文“运行:操作系统接手”一节。
如果删掉第一行 #include <iostream>,会在四步中的哪一步出错?
查看答案
在编译这一步。预处理没有问题(没有 #include 要处理),但编译器读到 std::cout 时,不知道 std 是什么,因为介绍它的那 8 万多行没有被复制进来。实际的报错:
no_include.fail.cpp:2:5: error: use of undeclared identifier 'std'
2 | std::cout << "Hello, world!\n";
| ^
1 error generated.no_include.fail.cpp:2:5 的意思是“这个文件的第 2 行第 5 列”,use of undeclared identifier 'std' 的意思是“用了一个没有声明过的名字 std”。
把 int main() 不小心写成了 int mian(),其他都不变。会在哪一步出错?为什么不是编译那一步?
查看答案
在链接这一步:
Undefined symbols for architecture arm64:
"_main", referenced from:
<initial-undefines>
ld: symbol(s) not found for architecture arm64
clang++: error: linker command failed with exit code 1 (use -v to see invocation)对编译器来说,mian 是一个完全合法的名字,它只是认真地把一个叫 mian 的函数翻译成了机器码,并不知道你本来想写 main。到了链接这一步,链接器要找程序的入口 main(报错里写成 _main),找遍了所有目标文件和库都没有,于是报 Undefined symbols(未定义的符号)。
这类错误的报错里没有行号,因为链接器面对的已经是机器码,不知道源代码的哪一行出了问题。
下面这个程序和本章的 hello.cpp 输出一模一样,只是用了 C 语言留下来的 <cstdio> 和 std::puts(puts 会自动加一个换行):
#include <cstdio>
int main() { std::puts("Hello, world!"); return 0;}预处理之后,它的行数会比 hello.cpp 的 84,254 行多还是少?大概差多少?
查看答案
少得多:只有 715 行,大约是 hello.cpp 的 118 分之一。<cstdio> 只提供一些简单的输入输出函数,<iostream> 则带来了一整套功能更多的输入输出系统(格式控制、各种语言和地区的习惯等等)。
这不是说应该用 puts。本书主要用 std::cout 和 C++20 的 std::format(1.9 节),它们更安全、更好用。这个练习只是想让你感受一下 #include 到底复制进来多少东西。
你在 Mac 上编译好了 hello,发给一位用 Windows 电脑的朋友。他能直接运行吗?如果不能,他要怎样才能运行这个程序?
查看答案
不能。hello 是 Mach-O 格式(macOS 的程序格式),里面是 ARM 处理器的机器码。Windows 用的是另一种程序格式(PE),大多数 Windows 电脑的处理器(x86-64)也不认识 ARM 的机器码。
应该把源代码 hello.cpp 发给他,他用 Windows 上的编译器(例如 Visual Studio)重新编译,就能得到一个 Windows 能运行的 hello.exe。这也是为什么很多软件的下载页面要分 Windows、macOS、Linux 好几个版本:它们是同一份源代码,分别在不同平台上编译出来的。
下一章(0.2)在你的电脑上装好编译器,亲手把这个程序编译、运行一遍。
图解系列橙皮书 · 图解游戏算法绿皮书 · 图解 C++(本书)蓝皮书 · 图解数据结构与算法(筹备中)
© 2026 XuYi · 原文 https://cpp.xuyi.dev/start/how-programs-run/
文章采用 CC BY-NC-SA 4.0 许可,转载请署名并附原文链接;代码以 MIT 协议开源。