预处理:翻译单元是怎么来的
上一篇的结尾,咱们把一个数字留在了那儿:六行的 hello.cpp,过了 -E,出来的是四万四千九百七十一行的 hello.i。四万多行的膨胀发生在哪一段,上一篇已经点过名了,就是排在最前面的那一段:预处理。今天咱们哪儿也不去,踏踏实实地待在这一段里,把 #include 到底干了什么、宏变成了什么、头文件守卫防的又是什么,一样一样地摆到证据跟前看。
照例交代环境:笔者的实验都在 WSL2 里跑,用的工具链是 GCC 16.2.1,这一篇里出现的每一段输出,都是真实跑出来的。您那边版本不同,行数、顺序之类的细节可能有出入,但这一段的行为本身,已经稳定了几十年。
#include 做的事,是原样粘贴
咱们平时写下 #include,嘴上说的是包含头文件,心里浮现的,往往是别的语言里那样的导入:把一个现成的模块挂进来,剩下的编译器自己会认。预处理器干的事比这个想象直接得多。它打开您指的那个文件,把内容一个字不改地抄进来,贴在 #include 所在的那一行。#include <iostream> 抄的是 iostream 的全文,#include "guarded.h" 抄的就是 guarded.h 的全文,连注释也一并进来了。
抄进来的文件里要是还有 #include,它就接着抄了下去,一层一层地递归,hello.i 的四万多行就是这么堆出来的。一个 .cpp 加上一路抄进来的全部内容,合在一起就有个正式的名字:翻译单元(translation unit)。咱们这一篇的标题,说的就是它的诞生。
咱们光说一个抄字,您可能还没什么体感,那咱们就直接做个实验:把同一个头文件包含两回,看看它会闹出什么样的动静。笔者准备了一个什么防护都没有的头文件:
// no_guard.h
struct Point { int x; int y; };咱们再写一个 use_twice.cpp,老老实实地把它包含两回:
// use_twice.cpp
#include "no_guard.h"
#include "no_guard.h"
int main() { Point p{1, 2}; return p.x; }要是 #include 背后真藏着去重的心思,刚才写的代码就应当照样能编过。咱们这就试试:
$ g++ -c use_twice.cpp
In file included from use_twice.cpp:2:
no_guard.h:1:8: error: redefinition of 'struct Point'
In file included from use_twice.cpp:1:
no_guard.h:1:8: note: previous definition of 'struct Point'每条 error 和 note 的下面还各跟着两行源码摘录,咱们这里略去了。这次的报错来得一点不含糊,struct Point 被定义了两回。这个输出里还藏着一个有意思的细节,值得咱们停半拍:报 redefinition 的是编译器,而不是预处理器。预处理器本身并不懂 C++ 的语法,它只管把那一行原原本本地抄两遍,文本交到编译阶段就撒手了,等编译器看见同一个结构体出现了两次,这才把它拦了下来。所以头文件要防的,不是同一个文件被读了两次,而是同一份定义被编译器看见两次。
那头文件自己能做什么?答案就是您在每个头文件开头都见过的那三行,它的名字叫头文件守卫(include guard)。
// guarded.h
#ifndef GUARDED_H
#define GUARDED_H
struct Point { int x; int y; };
#endif它的工作过程,咱们跟着预处理器走两遍。第一次粘贴开始的时候,GUARDED_H 还是个没被定义的宏,#ifndef 的条件成立,预处理器就走了进去,定义了 GUARDED_H,再把 struct 的原文原样交给编译器。第二次粘贴开始的时候,GUARDED_H 已经在了,条件就不成立了,整个文件都被整段跳过了,一个字也不往下面传了。同样包含两次的 use_twice_ok.cpp,咱们这回编译:
$ g++ -c use_twice_ok.cpp
(无输出 = 编译成功)这回终端安静了下来,咱们什么输出都没等到,编译就这么过去了。守卫没有什么魔法:它就是让第二次粘贴扑了个空。
和它配套的还有一句 #pragma once,您在不少代码库里大概也见过。它虽然不在 ISO 的标准里,不过主流编译器全都支持,它的含义就一句:同一个文件在一个翻译单元里头,只粘那么一次。两种写法您挑一种用就行,大项目里其实两种都常见。
宏:替换发生在文本这一层
宏是预处理器的另一半主业,咱们看一个最小的例子:
// macro_demo.cpp
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define GREETING "hello, preprocessor"
int limit = MAX(10, 20);
const char* msg = GREETING;老办法咱们是知道的:用 -E 停在预处理结束的那一步,再让 tail 只取最后面的几行:
$ g++ -E macro_demo.cpp | tail -5
int limit = ((10) > (20) ? (10) : (20));
const char* msg = "hello, preprocessor";展开的结果摆在眼前,咱们挨个认。GREETING 被原样换成了那个字符串字面量:一字不差。MAX(10, 20) 的展开更有意思:实参 10 和 20,被当成纯文本塞回宏体里 a、b 的位置,于是整行变成了 ((10) > (20) ? (10) : (20))。您注意,塞进去的是文本,不是求过值的数,预处理器压根没有去算的意思,它认的就只有字符。
您看完整的 -E 输出,还能发现一件小事:源文件开头的那行 // 注释,在里面已经找不到了。注释在预处理阶段就被换成了空白,轮是轮不到编译器的。
现在请您把目光挪到那一串括号上。假设宏体里的括号少写了一些,把它写成了 #define MAX(a, b) a > b ? a : b,那么 MAX(x, 20) * 2 就会展开成 x > 20 ? x : 20 * 2。按文本粘完了之后,那个 * 2 只跟住了 20,而没有跟住整个条件表达式,x 大于 20 的时候,算出来的就是 x 本身,而不是 x 的两倍,乘 2 整个都丢了。宏体里参数两侧的括号,连同套在最外层的那一对,防的全是这样的事:不管实参写成了什么样,括号都会逼着它以一个整体的样子落位。宏的名声不太好,根源也在这里:它不认识什么类型,也不认识什么作用域,认识的只有文本。
真要定义的若是常量,今天咱们有
constexpr。真要写的若是短小逻辑,比宏更体面的选择是 inline 函数和模板。它们凭什么顶上、ODR(单一定义规则,开卷那篇的路线图里提过一面)又是怎么一回事,模板与 ODR 那篇会专门来收拾的。
标准的口径:九个翻译阶段
前面咱们用的都是工程习惯的分法,也就是常说的那四段:预处理、编译、汇编、链接。而标准自己的口径比这更细。ISO C++ 把从源文件到可执行程序的全过程,规定成了九个翻译阶段,原文在标准的 [lex.phases] 一节,草案的全文放在 eel.is 上,cppreference 也有整理好的版本,页面的名字是 Phases of translation。九个阶段各自负责什么,笔者用大白话说一遍:
- 把源文件的字节,映射到统一的基本源字符集。
- 把反斜杠结尾的物理行,和下一行拼接成一个逻辑行。
- 把文本切成一个个预处理记号,注释替换成一个空格。
- 执行预处理指令:展开宏,处理条件编译,处理
#include,被包含的文件递归地从头经过第 1 到第 4 阶段。 - 字面量里的字符与转义序列,转换到程序运行时的编码。
- 相邻的字符串字面量拼接起来。
- 编译发生在这一步:预处理记号转换成真正的记号,再做语法分析、语义分析。
- 列出需要的模板实例化,并把它们完成。
- 链接:各个翻译单元、实例化结果与库,组合成一个完整的程序。
咱们对照着看,平时说的预处理大致对应第 1 到第 4 阶段,-E 拦下来的,就是第 4 阶段走完时交出的文本。四段论是把标准装进工具链之后的粗分法,方便咱们拦停和观察:上一篇咱们亲眼见过,cc1plus 一个程序就把前面一大段全包了,collect2 对应第 9 阶段的链接。
咱们把四段往九个阶段上一对,还有一段是没有着落的:汇编器。它在标准里找不到自己的位置,倒不是谁把它漏了,而是标准只规定到语言层面,翻成机器指令已经是各家工具的实现细节了。咱们再回头看第 4 阶段的收尾:这一步走完,所有的 # 指令处理完毕,翻译单元算是正式成型了,一份完整的 C++ 文本交到后面。
-E 输出开头的 # 行,是写给下一阶段的
咱们翻到 -E 输出的开头,会看到一批以 # 打头的行,后面跟着的是行号和文件名:
# 0 "macro_demo.cpp"
# 0 "<built-in>"
# 0 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3
# 0 "<command-line>" 2
# 1 "macro_demo.cpp"其实它们不是源码、也不参与编译,它们的名字叫行标记(linemarker),是写给编译器下一阶段看的:从这一行往后,哪个文件、第几行的内容,全都记了下来。它有什么用?您想想 hello.i 的处境,四万多行摊平的文本,要是 main 里出了问题,诊断信息必须知道自己说的到底是哪个文件。粘贴每个头文件的时候,输出里就多了一条对应的行标记,文件之间的边界,就这么被记了下来。行标记里的 <built-in> 那一行,对应的是编译器自带的一批预定义宏,马上咱们就会在 -dM 的输出里见到它们。
行标记的行尾,有时还会缀上别的数字,上面 stdc-predef.h 行尾的那个 3,标记的正是系统头,提示编译器对这段内容的诊断放宽一些。咱们知道有这个存在就行,细节就不用背了。
条件编译与预定义宏
守卫用过的 #ifndef,是条件编译的一次应用。它更大的用武之地,是让同一份源码在不同平台、不同标准版本下粘贴出不同的内容。判断的依据从哪来?一部分就来自编译器自带的那些预定义宏。咱们用一条命令把它们捞出来:
$ echo | g++ -dM -E -x c++ - | grep -E "__cplusplus|__GNUC__|__linux__|__x86_64__"
#define __GNUC__ 16
#define __cplusplus 202002L
#define __x86_64__ 1
#define __linux__ 1刚才的命令,咱们一段一段认:echo 送进去的是一个空输入,-x c++ 让 g++ 把标准输入当作 C++ 的源文件来处理,-E 做的还是预处理,-dM 要求把所有预定义宏的定义都打印出来,笔者再用 grep 从里面挑了四个。
__GNUC__是 16,这是 GCC 的大版本号,咱们写 GCC 专属扩展的分支时,靠它认。__cplusplus是 202002L,这个值对应 C++20。咱们没有写-std,GCC 16 默认用的就是 gnu++20,也就是 C++20 再加一摞 GNU 扩展。__x86_64__和__linux__是平台标记,咱们这台 x86-64 的 Linux,把这两个都定义上了。
有了这些宏在手,咱们就能写平台分支了:
#ifdef __linux__
// Linux 这边的实现
#else
// 其他平台的实现
#endif顺着同样的道理,咱们还能按标准版本分支:
#if __cplusplus >= 202002L
// C++20 起才能走的路子
#endif条件编译和 if/else 的差别在哪,咱们看剪的时机就明白了:剪枝发生在第 4 阶段,没被选中的那些文本直接就消失了,所以编译器根本看不见。落选的分支里,哪怕写着当前平台编不过的代码,甚至包含当前平台没有的头文件,程序照样好好的。if/else 就不一样了,两边的代码都得是合法 C++,运行的时候才挑路。
还有一组报告自身信息的宏,咱们也来认识一下:__FILE__ 展开成当前文件名,__LINE__ 展开成当前的行号,这俩报的是位置。__DATE__ 和 __TIME__ 展开成编译的时刻,报的是时间。日志和断言里最常见的就是它们:
std::cout << __FILE__ << ":" << __LINE__ << "\n";预处理器会把这一行所在的文件名和行号,如实填了进去。您再回头看看头文件守卫,它其实就是这几样东西凑在一起干活:#ifndef 负责的是提问,宏定义负责的是记状态,条件编译负责把第二次的粘贴整段跳过。
-H 与 -MM:把包含关系问出来
头文件的包含关系,咱们不用自己翻文件去找,预处理器倒是能主动汇报。您再加一个 -H,它就把整棵包含树打了出来:
$ g++ -H -c use_twice_ok.cpp
. guarded.h一个点表示的是一层包含。use_twice_ok.cpp 只包含了 guarded.h 一个头,所以这棵树短得可怜。您拿 hello.cpp 跑一遍 -H 就热闹了,标准头一个接一个地往右缩进去,一层又一层地叠起来,咱们对着这棵树看,44971 行的规模一下子就具体了。
咱们再请出 -MM,它输出的就不是代码了,而是另一种东西:依赖规则:
$ g++ -MM use_twice_ok.cpp
use_twice_ok.o: use_twice_ok.cpp guarded.h这行的格式咱们眼熟:make 的依赖规则,冒号前面的是目标,后面的是依赖。构建系统的头文件依赖就是从这来的:您改了 guarded.h,构建工具只要查一眼对应的规则,就知道 use_twice_ok.o 已经过期了,重新编译也就免不了了。没有这套机制的话,改一个头文件带来的就是全量重编,增量构建的安静,背后就是编译器顺手汇报的这些包含关系。
CMake 视角:这几件事都有人管
咱们日常多半不直接跟这些开关打交道,CMake 把常用的几件事都接管了,咱们一件一件对过去。
头文件的搜索路径,就是编译命令里的那些 -I。而在 CMake 里,咱们用目标化的写法,让路径跟着对应的目标走:
target_include_directories(app PRIVATE include)再提醒您一句,另一种是全局的 include_directories,它影响之后的所有目标,属于旧式的用法,咱们在新代码里能不碰就不碰:归哪个目标用的头文件,就让哪个目标声明自己的路径。
依赖的这件事,咱们不用自己跑 -MM。CMake 默认那一档生成的就是 Makefile,也就是常说的 Make 生成器,它给编译命令默认挂的正是 -MMD 一类的依赖输出开关。您改了头文件,该重编什么、不该重编什么,交给构建系统自己查就好了,不用您操心。
预编译头要解决的,就是粘贴带来的编译耗时。咱们上一篇里量过一次:六行的 hello.cpp,粘贴完了就是四万多行。要是工程里几百个 .cpp 都这么干,每个都把同一批头文件的全文从头粘贴一遍、再从头分析一遍,时间就都耗在这些重复的劳动上了。target_precompile_headers 做的,是把常用头的处理结果做成一份可复用的产物,而后各个翻译单元直接接着用:
target_precompile_headers(app PRIVATE <vector> <string>)它省的是时间,不改的是语义,这一点请您放心:每个翻译单元看到的,仍然是粘贴齐全的完整文本。哪些头值得放进去、参数又怎么挑,咱们这里点到为止,您真用上的时候,翻一翻 CMake 自己的文档就有答案。
预处理交出的,是一份纯 C++ 文本
hello.i 的那四万多行,咱们现在全看得懂了:头文件的内容都贴在里面,宏没了,注释没了,连一条 # 指令也不剩了,咱们的 main 还躺在最底下。这样的文本就是翻译单元,是纯粹的 C++。
预处理器的工作到此为止。接下来的活,是编译器的:把文本里的每个函数、每条语句翻成汇编。这是下一篇要干的事,咱们把 hello.i 留好,它就是那篇的原料。