深入c语言和程序运行原理(10)预处理器是怎样处理程序代码的?

2022年10月11日 83点热度

预处理器是怎样处理程序代码的

C 预处理器是 C 标准中的另一块重要内容。对代码进行预处理,是 C 源代码在被“真正”编译,并生成机器代码前的重要一环。合理使用预处理指令,可以让源代码根据不同的环境信息进行动态变化,并生成适合在当前环境下编译的 C 代码。这里我们提到的“环境”,一般与目标操作系统、CPU 体系架构,以及当前平台上各系统库的支持情况有关。

除此之外,预处理器还为我们提供了一定的能力,可以更加高效、灵活地组织 C 源代码。比如,我们可以对一个完整的 C 程序进行结构化拆分,根据代码在语法结构或功能定位上的不同,将它们分别整理在独立的 C 源文件中。而在包含有程序入口 main 函数的源文件内,我们便可以通过 #include 预处理指令,在编译器开始真正处理 C 代码前,将程序运行所需要的其他代码依赖包含进来。

那么今天,我们就来看看有关 C 预处理器的内容。接下来,我将介绍 C 预处理器的相关背景知识、预处理的基本流程,以及宏编写技巧和使用注意事项。

C 预处理器的相关背景知识

预处理器被引入 C 标准的时间比 C 语言诞生晚了大约一年。1973 年左右,在贝尔实验室研究员 Alan Snyder 的敦促下,预处理器被正式整合至 C 语言中。它的最初版本只拥有基本的文件包含和字符串替换能力。而在此后不久,它被进一步扩展,加入了带参数的宏以及条件编译等功能。在随后发布的 ANSI C 标准中,预处理器的能力再次得到了加强。

另外你需要知道的是,C 预处理器并不仅仅可以用在 C 语言上,在 C++、Objective-C 等基于C 的“后继语言”中,这套预处理器语法仍然适用。

除此之外,也许你也还并不清楚这一点:为什么使用预处理器语法 #define 定义出来的符号被称为宏(macro)?而那是因为在希腊语中,macro 通常会被作为一个单词前缀,用来表示体积或数量上的“大”和“多”。而在 C 代码中,当一个宏被展开和替换时,不是也有类似的效果吗?

到这里,有关 C 预处理器的一些背景知识我就介绍完了。下面,就让我们来看看编译器是如何对 C 代码进行预处理的。

预处理是怎样进行的?

对代码进行预处理是整个 C 程序编译流程中的第一环。在这一步中,编译器会对源代码进行分析,并通过查找以 “#” 字符开头的代码行,来确定预处理器指令的所在位置。接下来,通过下面这些步骤,编译器可以完成对代码的预处理工作:

  1. 删除源代码中的所有注释;
  2. 处理所有宏定义(#define),并进行展开和替换;
  3. 处理所有条件预编译指令(如 #if、#elif),仅保留符合条件的代码;
  4. 处理文件包含预编译指令(#include),将被包含文件的内容插入到该指令的所在位置;
  5. 处理其他可以识别的预处理指令(如 #pragma);
  6. 添加其他具有辅助性功能的注释信息。

为了进一步观察编译器在预处理阶段对 C 代码的处理过程,这里我们可以进行一个简单的实验:将下面这段代码保存在文件 “macro.c” 中,并通过命令 “gcc -O0 -Wall -E ./macro.c -o macro.l” 对它进行编译。

#pragma GCC warning "Just FYI!"
#include <stdbool.h>
#define PI 3.14
#define SQUARE(x) (x * x)
int main(void) {
    #if defined PI
    // Some specific calculations.
    const double area = SQUARE(5) * PI;
    const bool isAreaGT100 = area > 100.0;
    #endif
    return 0;
}

眼尖的你会发现,我们在编译命令中使用到了名为 “-E” 的参数。该参数的作用是让编译器仅对源代码执行预处理阶段的一系列操作,之后就停止运行。当编译完成后,你可以在编译目录内找到名为 “macro.l” 的文件。而在这个文件中,便包含有源代码在经过预处理阶段后得到的中间代码结果。其中的内容如下所示(注意,不同的编译器和版本生成的文件内容可能有所不同):

# 1 "macro.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 31 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 32 "<command-line>" 2
# 1 "macro.c"
# 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stdbool.h" 1 3 4
# 3 "macro.c" 2
int main(void) {
    const double area = (5 * 5) * 3.14;
    const
    # 8 "macro.c" 3 4
    		_Bool
    # 8 "macro.c"
    		isAreaGT100 = area > 100.0;
    return 0;
}

可以看到,在这段文本中,所有之前在 C 源代码中以 “#” 开头的预处理指令都已经被移除;宏常量 PI 和宏函数 SQUARE 已经完成了展开和替换;头文件 “stdbool.h” 中的内容也已经被插入到了源文件中(该文件内为宏 bool 的定义,这里已被替换为了 _Bool)。除此之外,一些带有辅助功能的信息也以 linemarker 的形式插入到了该文件中,供后续编译阶段使用。

定义宏函数时的常用技巧

预处理器在进行宏展开和宏替换时,只会对源代码进行简单的文本替换。在某些情况下,这可能会导致宏函数所表达的计算逻辑与替换后 C 代码的实际计算逻辑产生很大差异。因此,在编写宏函数时,我们要特别注意函数展开后的逻辑是否正确,避免由 C 运算符优先级等因素导致的一系列问题。

接下来,就让我们一起看下:当在 C 代码中使用预处理器时,有哪些 tips 可以帮助我们避免这些问题。

技巧一:为宏函数的返回值添加括号

对于大多数刚刚接触 C 预处理器的同学来说,我们可能会在不经意间,写出类似下面这样的代码:

#include <stdio.h>
#define FOO(x) 1 + x * x
int main(void) {
    printf("%d", 3 * FOO(2));
    return 0;
}

这里,我们定义了一个名为 FOO 的宏函数,该函数接收一个参数 x,并返回这个参数在经过表达式 1 + x * x 计算后的结果值。在 main 函数中,我们以数值 2 作为参数,调用了该宏函数,并通过 printf 函数打印了数字 3 与宏函数调用结果值的乘积。

按照我们对函数的理解,这里的宏函数在被“调用”后,会首先返回表达式的计算结果值 5(1 + 2 * 2)。随后,该结果值会再次参与到函数外部的乘积运算中,并得到最终的打印结果值 15。但事实真是如此吗?

实际上,宏函数的展开与 C 函数的调用过程并不相同。经过编译器的预处理后,上述代码中对第四行 printf 语句的调用过程会被变更为如下形式:

printf("%d", 3 * 1 + 2 * 2);

可以看到,这里的宏函数 FOO 在被展开时,并不会优先对其内部的表达式进行求值,相反,只是简单地对传入的参数进行了替换。因此,当编译器按照展开后的结果进行计算时,由于表达式中乘法运算符 “*” 的优先级较高,进而导致整个表达式的计算顺序发生了改变,所以,计算结果也就出现了偏差。那如果我们为宏函数的整个返回表达式都加上括号,结果会怎样呢?显而易见,此时表达式 (1 + 2 * 2) 会被优先求值。 3 * FOO(2) 的计算结果符合我们的预期。

技巧二:为宏函数的参数添加括号

用上面的技巧,我们已经对宏函数 FOO 进行了优化,以保证在某些情况下,“返回的”表达式能够被当作一个整体进行使用。但这样就万无一失了吗?其实,类似的问题还可能会出现在宏函数的参数上,比如下面这个例子:

#include <stdio.h>
#define FOO(x) (1 + x * x)
int main(void) {
    printf("%d", FOO(1 + 2));
    return 0;
}

在这里,我们改变了宏函数 FOO 的使用方式,直接将表达式 1 + 2 作为参数传递给了它。同样地,由于编译器在处理宏函数时,仅会进行实参在各自位置上的文本替换,传入函数的表达式并不会在函数展开前进行求值。因此,经过编译器的预处理后,上述代码中第四行对 printf 语句的调用过程会被变更为如下形式:

printf("%d", (1 + 1 + 2 * 1 + 2));

由于乘法运算符 “*” 的存在,此时整个表达式的求值顺序发生了改变。本该被优先求值的子表达式 1 + 2 并没有被提前计算。很明显,这并不是我们在设计 FOO 函数时所期望的。而通过为宏函数定义中的每个参数都加上括号,我们便可以解决这个问题。

技巧三:警惕宏函数导致的多次副作用

那么,现在的宏函数 FOO 还会有问题吗?让我们继续来看这个例子:

#include <stdio.h>
#define FOO(x) (1 + (x) * (x))
int main(void) {
    int i = 1;
    printf("%d", FOO(++i));
    return 0;
}

在上面这段代码中,我们“装配”了经过两次优化升级的宏函数 FOO。只是相较于前两种使用方式,这里我们在调用该函数时,传入了基于自增运算符的表达式 ++i 。按照常规的函数调用方式,变量 i 的值会首先进行自增,由 1 变为 2。然后,该结果值会作为传入参数,参与到宏函数中表达式 1 + (x) * (x) 的计算过程,由此可以得到计算结果 5。

但现实往往出人意料:同之前的例子类似,传入宏函数的表达式实际上并不会在函数被“调用”时提前求值。因此,上述 C 代码中的第五行语句在宏函数实际展开时,会变成如下形式:

printf("%d", (1 + (++i) * (++i)));

到这里,我想你已经知道了问题所在:经过宏替换的 C 代码导致多个自增运算符被同时应用在了表达式中,而该运算符对变量 i 的副作用产生了多次。

因此,在使用宏函数时需要注意,宏函数的“调用”与 C 函数的调用是完全不同的两种方式。前者不会产生任何栈帧,而只是对源代码文本进行简单的字符替换。所以,对于替换后产生的新代码,其计算逻辑可能已经发生了变化,而这可能会引起程序计算结果错误,或副作用产生多次等问题。

技巧四:定义完备的多语句宏函数

到这里,对于定义简单宏函数时可能遇到的一系列问题,相信你都能处理了。但当宏函数逐渐变得复杂,函数体内不再只有一条语句时,新的问题又出现了。

通常情况下,为了与 C 代码的风格保持一致,在调用宏函数时,我们也会习惯性地为每一个调用语句的末尾加上分号。但也正是因为这样,当含有多行语句的宏函数与某些控制语句一起配合使用时,可能会出现意想不到的结果。比如下面这个例子:

#include <stdio.h>
#define SAY() printf("Hello, "); printf("world!")
int main(void) {
    int input;
    scanf("%d", &input);
    if (input > 0)
    SAY();
    return 0;
}

当我们习惯使用 C 代码的执行思维来看待宏函数时,上述代码的执行情况应该是这样的:程序接收用户输入的字符,并将其转换为数字值。若该值大于 0,则宏函数内的两条 printf 语句被执行,并输出字符串 “Hello, world!”。否则,程序直接退出。但现实的情况却是,无论用户输入何值,字符串 “world!” 都会被打印。

而问题就出现在宏函数 SAY 被展开和替换后,原本“封装”在一起的两条 printf 语句被拆分开来。其中的第一条语句成为了 if 条件控制语句的执行内容;而第二条语句由于没有大括号的包裹,则直接被“释放”到了 main 函数中,成为了该函数返回前最后一条会被执行的语句。

那么,应该怎样解决这个问题呢?

既然我们的目的是让编译器在处理程序代码时,能够将宏函数内的所有语句当作一个整体进行处理,那么有没有一种合法的 C 语言结构,它可以作为一种复合语句使用,其内部的语句只会被执行一次,并且在语法上,它还需要以分号结尾?

很巧,迭代语句 do…while 便可以满足这个要求。如下面这段代码所示,我们使用该语句,改写了宏函数 SAY 的实现方式。

#include <stdio.h>
#define SAY() \
    do { printf("Hello, "); printf("world!"); } while(0)
int main(void) {
    int input;
    scanf("%d", &input);
    if (input > 0)
    SAY();
    return 0;
}

可以看到,通过将 while 关键字中的参数设置为 0,我们可以保证整个迭代语句仅会被执行一次。而 do…while 语句“天生”需要以分号结尾的性质,也正好满足了宏函数替换后的 C 语法格式要求。并且,对于 while(0) 这种特殊的迭代形式,大多数编译器也会通过相应的优化,去掉不必要的循环控制结构,以降低对程序运行时性能的影响。

何时使用预处理器?

讲了这么多预处理器的使用技巧,最后还是要提醒你:预处理器是一把“双刃剑”。对它的合理使用,可以让我们的程序具备更强的动态扩展能力;相反,如果任意乱用,就会导致程序源代码的可读性大大降低,甚至引入难以调试的 BUG。

通常,在以下三个场景中,你可以视情况选择是否使用预处理器:

  • 定义程序中使用到的魔数。这里提到的魔数,主要是指那些用于控制程序运行状态、具有特定功能意义的参数。这些参数可以使用预处理器以宏的形式定义,并在程序编译前内联到源代码中使用;
  • 基于特定运行环境的条件编译。我们可以通过特定的宏(比如编译器预定义宏、C 语言内置宏等)来检测当前编译环境的状态,并以此调整程序需要启用的特定功能;
  • 封装代码模板。我们可以通过宏的形式,封装需要重复出现的代码片段,并将它们应用在循环展开等场景中。

当然,真实的使用场景并不局限于这三类。但还是要强调下:在使用预处理器时,保持谨慎小心是必要的。

总结

今天我主要介绍了与 C 预处理器有关的一些内容,包括相关背景知识、编译器处理方式,以及使用技巧等。

通过 C 预处理器,我们可以让编译器在真正开始处理 C 语法代码前,先对源码进行一系列必要的转换。这些转换可以让我们引入代码正常编译所需要的各类依赖项,动态修改代码以适应不同的编译环境,甚至根据需要自动生成部分 C 代码。对预处理器的合理使用,可以让我们的程序具备一定的“弹性伸缩”能力,并使程序的可配置性大大增强。

另一方面,宏函数的运作方式又与 C 函数有着巨大的区别。其中,前者在“调用”时仅会做源代码文本上的匹配与替换。因此,在处理宏函数参数以及宏函数体内的多行语句时,需要通过添加括号、使用 do…while 语句等技巧,来对参数、返回值与函数体进行“封装”。

最后,需要注意预处理器的合适使用场景。在 C 语言中,预处理器通常可以被应用在程序魔数定义、代码条件编译,以及代码模版封装等场景中。只有谨慎、合理地使用,我们才能够享受到 C 预处理器带来的巨大价值。

思考题

你知道 C 预处理运算符 “#” 与 “##” 的用法吗?

Baimi

世上只有两种编程语言:一种是总是被人骂的,一种是从来没人用的。