当前位置：首页 > news >正文

【C】预处理详解

news 来源：原创 2025/5/6 12:39:19

在上一篇文章中，简单讲解了一个C程序是如何从一句句C代码变为一个个二进制指令，并最终变成可执行程序成功运行。在预处理、编译、汇编、链接四个步骤中，预处理阶段做的事情特别多，接下来我们就来讲解一下在预处理阶段处理的一些预处理指令。

这些预处理指令包括一些预定义符号，#define，#和##，#undef，条件编译，最后再讲解一下头文件包含的相关问题。

1 预定义符号

2 #define

1） #define定义常量

2） #define定义宏

3）带有副作用的宏参数

4）宏替换的规则

5）宏与函数的对比

3 #和##运算符

1） #运算符

2） ## 运算符

4 #undef

5 条件编译

6 头文件的包含

1）两种包含方式的区别

2）重复包含

1 预定义符号

在C语言中，设置了一些可以在预处理阶段处理的预定义符号，这些符号可以直接使用，包括：

//__为两个下划线
1  __FILE__ //进行编译的文件2  __LINE__ //当前代码所在行3  __DATE__ //文件被编译的日期4  __TIME__ //文件被编译的时间5  __STDC__ //当前编译器是否符合ANSI C(标准C)，如果符合会变成1，不符合会变成0或者未定义

例子：

#include<stdio.h>int main()
{printf("%c\n", __FILE__);printf("%d\n", __LINE__);printf("%c\n", __DATE__);printf("%c\n", __TIME__);//printf("%d\n", __STDC__);return 0;
}

运行结果为：
由于VS编译器并不是完全按照ANSI C来设计的，所以__STDC__是未定义的，如果大家有别的编译器可以试一下。

2 #define

#define是C语言中经常使用的一个预处理指令，他的作用主要包括两个方面 -- 定义常量和定义宏。

1） #define定义常量

#define 可以把一个符号定义为一个常量，类似于枚举变量，其语法为：

#define name stuff

name是要定义的符号，stuff为该符号对应的常量值，#define与name之间有一个空格，name与stuff之间有一个空格，用#define定义常量的例子如下：

#include<stdio.h>
#define M 100int main()
{int a = M;printf("%d\n", a);return 0;
}

运行结果：

#define定义常量在预处理阶段就会直接把定义的符号替换为其值，比如上面那个代码在预处理阶段就是被处理成如下代码（当然头文件也会在预处理阶段被展开，但是太长，这里就省略了）：

int main()
{int a = 100;printf("%d\n", a);return 0;
}

#define除了可以用符号定义常量之外，还可以用符号来定义一些语句，如：

#include<stdio.h>
#define CASE break;caseint main()
{int n = 0;scanf("%d", &n);switch(n){case 1:printf("hello world\n");CASE 2:printf("hello w\n");CASE 3:printf("hello y\n");CASE 4:printf("hello f\n");}return 0;
}

在之前的switch分支语句中，为了不发生错误，需在每一种case后面加上break语句，让程序跳出选择，而用#define定义了CASE之后，就可以直接写CASE就可以了，就不会忘记在case后面加break了，因为用#define定义了CASE之后，程序在预处理阶段就会变为：

int main()
{int n = 0;scanf("%d", &n);switch(n){case 1:printf("hello world\n");break;case 2:printf("hello w\n");break;case 3:printf("hello y\n");break;case 4:printf("hello f\n");}return 0;
}

运行结果为：

当然，#define既然可以用来定义一句代码，如：

#include<stdio.h>
#define PRINT printf("hello world")int main()
{PRINT;return 0;
}

在预处理阶段代码会变为：

int main()
{printf("hello world");return 0;
}

运行结果为：

经过以上代码，其实可以发现#define本身类似于一种替换机制，会将后面定义的值在代码中将前面定义的符号替换掉。

但使用#define时，要注意不要在后面加上分号，因为#define会将后面的内容直接替换，所以有时候会出现错误，如：

#include<stdio.h>
#define M 100;int main()
{printf("%d\n", M);return 0;
}

预处理阶段代码变为：

int main()
{printf("%d\n", 100;);return 0;
}

语法会出现错误，所以会直接报错。

2） #define定义宏

#define 不仅可以用来定义常量，还可以用来定义宏，定义宏的语法为：

#define name(parament-list) stuff

name为宏的名字（一般都命名为大写），parament-list为参数列表，类似于函数的参数列表，stuff为宏要实现的功能，要注意的是，name与后面那个括号必须紧密相连，不能有空格，要不该宏会被认为是定义常量，使用宏的一个例子为：

#include<stdio.h>
#define ADD(X, Y) X + Yint main()
{int a = 5;int b = 10;int ret = ADD(a, b);printf("%d\n", ret);return 0;
}

运行结果为：

但是这样写宏是具有问题的，例如以下这个例子：

#include<stdio.h>
#define MUL(X, Y) X * Yint main()
{int ret = MUL(5+2, 1+3);printf("%d\n", ret);return 0;
}

我们希望这个乘法宏算出的结果为28，但实际上结果确是10：

出现这个错误结果的原因就是#define定义宏也是一种替换机制，就是用后面的后面的表达式来直接替换前面的宏，参数本身并不会进行计算，所以上面那个乘法宏会被替换为以下代码：

int main()
{int ret = 5 + 2 * 1 + 3;printf("%d\n", ret);return 0;
}

所以运算符的优先级会影响运算的结果。要解决这个问题也很简单，只要给每个参数加上括号就可以了：

#include<stdio.h>
#define MUL(X, Y) (X) * (Y)int main()
{int ret = MUL(5+2, 1+3);printf("%d\n", ret);return 0;
}

运行结果为：

但是只给参数加上括号有时还会发生错误，如：

#include<stdio.h>
#define DOUBLE(X) (X) + (X)int main()
{int ret = 11 * DOUBLE(20);printf("%d\n", ret);return 0;
}

我们期望的正确结果为440，但实际上结果为240：

因为宏被替换后，代码变为了：

int main()
{int ret = 11 * (20) * (20);printf("%d\n", ret);return 0;
}

要解决这个问题就需要在整体再套上一个括号：

#include<stdio.h>
#define DOUBLE(X) ((X) + (X))int main()
{int ret = 11 * DOUBLE(20);printf("%d\n", ret);return 0;
}

所以以后在使用#define定义宏的时候，由于其本身的替换机制，我们需要在保证正确的前提下，尽量在能加括号多加括号，才能保证#define定义宏的正确性。

3）带有副作用的宏参数

当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用（比如b = a++，不仅b = a + 1，且a也+1），那么在使用宏的时候就可能出现危险，导致不可预测的后果。副作用就是表达式求值的时候出现的永久性后果。

比如以下这个代码，就说明了带有副作用的宏参数出现的问题：

#include<stdio.h>
#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))//下面这个代码结果是多少呢？
int main()
{int a = 5;int b = 6;int max = MAX(a++, b++);printf("%d\n", max);printf("%d\n", a);printf("%d\n", b);return 0;
}

运行结果：

首先，上述代码会在预处理阶段被替换为以下代码：

int main()
{int a = 5;int b = 6;int max = ((a++) > (b++) ? (a++) : (b++));printf("%d\n", max);printf("%d\n", a);printf("%d\n", b);return 0;
}

由于是后置++，所以先使用，后++，所以前面 > 比较结果为假，会执行后面的b++代码，同时a与b都自增了1，变为了6和7，然后后面的b++，也是后置++，会把b的值赋给max，所以max是7，b再自增1，变为了8，所以输出结果就是7,6,8。

所以在这里由于宏参数带有副作用，产生了意想不到的后果，本来我们期望得到的最大值为6，然后a，b各自增1，结果答案出乎我们意料，这就是带有副作用的宏参数可能产生错误的结果。所以，当参数带有副作用时，我们应该尽量用函数来解决。

4）宏替换的规则

前面我们了解到 #define 定义常量和宏本质上就是一种替换机制，所以这里我们来了解一下宏替换的规则：

(1)  在调用宏时，首先对参数进行检查，看看是否有#define定义的符号，如果有，这些符号首先被替换(2)  替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。(3)  最后，再对结果文件进行扫描，看看它是否包含任何由 #define 定义的符号。如果有，就重复上述处理过程。如：对于以下代码
#include<stdio.h>
#define M 10
#define ADD(X, Y) ((X) + (Y))int main()
{int a = 20;int add = ADD(a, M);return 0;
}//第一步：首先替换参数中被#define定义的符号
int main()
{int a = 20;int add = ADD(a, 10);return 0;
}//第二步：再把宏替换掉
int main()
{int a = 20;int add = ((a) + (10));return 0;
}

使用宏的时候也有两个注意事项：

(1)  对于宏，其不能递归(2)  当预处理器搜索 #define 定义的符号时，字符串常量的内容不被搜索

对于第二点，如以下这个代码：

#include<stdio.h>
#define M 10int main()
{//"M = %d"字符串中的 M 并不会被替换为10，也就是不会被搜索printf("M = %d", M);return 0;
}

5）宏与函数的对比

在形式上看起来，宏和函数看起来类似，使用方式都是名字加上后面传参数，所以这里对他们俩进行一个对比：

宏与函数的对比
属性	宏	函数
代码长度	宏在每次使用时都会直接替换，在原代码长度基础上，大大增加了代码长度	函数代码只出现在一个地方，只会产生一份代码，每次使用函数时，都会去调用同一份代码
执行速度	比函数调用更快	存在传参，开辟函数栈帧，拷贝返回值等额外开销，比起宏来相对较慢
操作符优先级	如果不加足够的括号，可能会因为操作符优先级产生错误的结果	函数只在函数调用时求值一次的结果传递给函数，并且会返回一个值，不会因为操作符优先级而发生错误
带有副作用的参数	如果带有副作用的宏参数在宏中被多处替换，就会被多次计算，产生不可预料的后果	函数参数只在传值的时候被求值一次，更容易控制
参数类型	宏参数与类型无关，只要对参数操作合法，任何类型参数都可以	函数参数是受参数类型限制的，所以不同类型的参数需要不同的函数
调试方面	不方便调试	可以逐语句调试
递归	不能递归	可以递归

3 #和##运算符

1） #运算符

# 运算符是将宏的一个参数转换为字符串字面量，仅允许出现在带参数的宏的替换列表中。

在举具体例子之前，我们先来看一个使用 printf 函数的例子：

#include<stdio.h>int main()
{printf("hello""world\n");return 0;
}

运行结果为：
当printf函数里面有多个字符串时，printf函数会合成一个字符串进行打印。

# 运算符功能类似于“字符串化”，使用#运算符的例子如下：

#include<stdio.h>
#define PRINT(v, f) printf("the value of "#v" is "f, v)int main()
{int a = 10;PRINT(a, "%d\n");float m = 2.2f;PRINT(m, "%f\n");return 0;
}

宏替换之后代码为：

#include<stdio.h>
#define PRINT(v, f) printf("the value of "#v" is "f, v)int main()
{int a = 10;printf("the value of ""a"" is ""%d\n", v);float m = 2.2f;printf("the value of ""m"" is ""%f\n", v)return 0;
}

所以运行结果为：

这里就是将宏参数 v 通过增加一个 # 运算符，在替换时会变成 "v"。

2） ## 运算符

## 运算符的作用是可以将两边的符号合成一个符号，允许宏定义从分离的文本片段创建标识符。因此，## 被称为记号粘合，粘合之后所生成的标识符必须是合法的。

举个例子：

//使用宏定义一个任意类型的求最大值函数
#include<stdio.h>
#define GEN_MAX(type)\
type type##_Max(type x, type y)\
{\return x > y ? x : y;\
}GEN_MAX(int);int main()
{int max = int_Max(3, 5);printf("%d\n", max);return 0;
}

运行结果：

代码中的 \ 为换行符，如果一行代码写不开，可以用这个符号换行，但注意：该符号后面只能跟换行。

那么为什么可以直接调用呢？因为 #define 定义的宏会在预处理阶段就被替换，而运行阶段调用函数时，函数就已经产生了，所以可以直接调用。

4 #undef

#undef 该预处理指令是用来取消 #define 定义的，如：

#define M 10int main()
{printf("%d\n", M);//把M重新定义
//先移除之前M的定义
#undef M
#define M 100printf("%d\n", M);return 0;
}

运行结果：

5 条件编译

如果要将一条语句（一组语句）编译或者放弃就可以使用条件编译指令。这些条件编译指令通过满足一定条件来控制某些语句的编译与否，条件编译指令包括：

(1)
#if 常量表达式(一定要是常量，因为变量在预处理时还未有值)//...
#endif(2)  多个分支的条件编译
#if 常量表达式//...
#elif 常量表达式//...
#else//...
#endif(3)判断是否定义过
//如果symbol被定义过，底下的语句就参与编译
#if defined(symbol)
#ifdef symbol//....//如果symbol没有被定义过，底下的语句就参与编译
#if !defined(symbol)
#ifndef symbol(4)条件编译指令支持嵌套定义

举个例子：

#include<stdio.h>
#define M 10int main()
{
#if defined(M)#if Mprintf("hello world\n");#elseprintf("hello w\n");#endif
#endif#if !defined(M)#if Mprintf("hello y\n");#elseprintf("hello f\n");#endif
#endifreturn 0;
}

运行结果：

使用条件编译指令时需要注意在每一个 #if 后面都必须加上 #endif ，包括 #if，#ifdef ，#if defined，#ifndef，#if !defined。

6 头文件的包含

1）两种包含方式的区别

我们写C程序的时候都会在前面包含头文件来使用库函数，其实包含头文件有两种方式，一种是在 #include 后面加上尖括号（<>），另一种是在后面加上双引号("")，这两种包含头文件的方式是有区别的，区别就在于查找策略的不同：

(1)  <> 包含头文件是在标准路径下查找，如果查找不到就提示编译错误(2)  "" 包含头文件是先在源文件所在目录下查找，如果没有查找到，编译器再像查找库函数头文件一样在标准路径位置下查找头文件

所以其实包含库函数的头文件也可以用 "" 来包含，如：

#include "stdio.h"

这样包含也是可以的，不会报错，但是一般不会这样包含，因为这样编译器先默认会去源文件所在目录下去查找，降低了查找效率，所以包含库函数的头文件用 <> 来包含，自己写的函数的头文件只能用 "" 来包含。

2）重复包含

由于预处理阶段会把 #include 包含的头文件全部展开，将代码放到预处理后的文件中（.i 为后缀的文件），如果一个头文件在一个文件中被多次包含，就会导致多出一些相同的代码，导致代码量大量增加，所以避免头文件的重复包含就显得特别重要。避免头文件包含的方式有两种：

(1)  使用条件编译指令(2)  使用 #pragma once 预处理指令

对于第一种方式例子如下：

//add.h
#include<stdio.h>#ifndef __ADD-H__
#define __ADD-H__int Add(int x, int y)
{return x + y;
}#endif

其实对于第二种方式，我们在新建一个头文件的时候，编译器会自动在第一行加上这句预处理指令：

编译器这样做就是为了防止头文件的重复包含问题。

到这里，C语言就全部结束了。从刚开始的"hello world"再到后来的顺序、分支、循环结构，再到后来的指针、结构体、内存管理，再到编译和链接，以及最后的预处理详解，一步步走过来相信大家也是收获满满。之后，我也会继续学习数据结构以及C++的知识，并不定期更新，请大家敬请期待哦。

1 预定义符号

2 #define

1） #define定义常量

2） #define定义宏

3） 带有副作用的宏参数

4） 宏替换的规则

5） 宏与函数的对比

3 #和##运算符

1） #运算符

2） ## 运算符

4 #undef

5 条件编译

6 头文件的包含

1） 两种包含方式的区别

2） 重复包含

相关文章：

3）带有副作用的宏参数

4）宏替换的规则

5）宏与函数的对比

1）两种包含方式的区别

2）重复包含