前言：

预处理也叫预编译，是编译代码时的第一步，经过预处理后生成一个.i文件，如果不明白编译与链接作用的小伙伴可以先看看博主的上一篇博客—— ，不然知识连贯性可能会显得很差哦。

正文目录：

1. 预定义符号
2. #define定义常量
3. #define定义宏
4. 带有副作用的宏参数
5. 宏替换的规则
6. 宏与函数的对比和命名约定
7. #和##
8. #undef
9. 条件编译
10. 头文件的包含
11. 其他预处理指令......

1.预定义符号

如下为c语言中的预定义符号：

• __FILE__   //进⾏编译的源⽂件
• __LINE__   //⽂件当前的⾏号
• __DATE__   //⽂件被编译的⽇期
• __TIME__   //⽂件被编译的时间
• __STDC__   //如果编译器遵循ANSI C，其值为1，否则未定义

这些都是我们可以直接使用、在预处理阶段就已经处理了的。

我们举个例子：

2.#define定义常量

基本语法形式如下：

#define name stuff        //其中name表示名字， stuff表示（被替换的）内容

当我们用该语法后，stuff就被name给替换了。

示例如下：

此时100就被M替换了，因此a输出结果为100。

而在预处理阶段，会将#define定义的“名字”替换为它所表示的常量，比如说上图中的a = M ，经预处理后实际的代码形式为a = 100。

3.#define定义宏

如下为宏的申明方式：

#define name( parament-list ) stuff   //parament-list为参数列表，stuff为内容。

#define 机制包括了⼀个规定，允许把参数替换到⽂本中，这种实现通常称为宏（macro）或定义宏（define macro）。

示例如下：

但是需要注意，#define定义宏可能会带来运算级优先级的问题。

就跟上面同样的题目，我们换种写法如下：

可以发现，我们M（a）中的a本来为10，但当我们写成9 + 1后结果与我们所期待的不符。

这是为什么呢？——上文讲过，“在预处理阶段，会将#define定义的“名字”替换为它所表示的常量”，此处的“名字”就相当于M（9 + 1）。当替换后，该行代码就变为了“a = 9 + 1 * 9 + 1”。

容易发现跟我们的要求不符，这就是运算符优先级的问题。

我们可以这样修改：

如上图所示，我们加个小括号就可以了。因此我们用#define定义宏时，一定不要吝啬括号。

4.带有副作用的宏参数

简单来讲副作用就是说会导致参数发生改变。

严谨点的就是下面的说法：

当宏参数在宏的定义中出现超过⼀次的时候，如果参数带有副作⽤，那么你在使⽤这个宏的时候就可能出现危险，导致不可预测的后果。副作⽤就是表达式求值的时候出现的永久性效果。

例如：

x + 1;      //不带副作⽤
x++;       //带有副作⽤

具体示例如下：

当我们后续再使用代码中的a、b时，就可能不是我们所期望的值了。

5.宏替换的规则

这个就是偏概念性的东西了，规则如下：

在程序中扩展#define定义符号和宏时，需要涉及⼏个步骤。

1. 在调⽤宏时，⾸先对参数进⾏检查，看看是否包含任何由#define定义的符号。如果是，它们⾸先被替换。
2. 替换⽂本随后被插⼊到程序中原来⽂本的位置。对于宏，参数名被他们的值所替换。
3. 最后，再次对结果⽂件进⾏扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

我们给出一个示例，按照宏替换的规则进行替换，如下图所示：

然后我们就将第二个宏定义的内容替换到主函数中的相应宏中，

因此最终主函数的第一行代码被替换为了：int m = ((a) > (b) ? (a) : (b));

6.宏与函数的对比和命名约定

我们先讲二者的命名约定：

容易发现，函数的宏的使⽤语法很相似。所以语言本⾝没法帮我们区分⼆者。
因此我们平时的⼀个习惯是：
把宏名全部⼤写
函数名不要全部⼤写

宏与函数的对比

宏一般用于简单的运算，因为如果简单的运算就使用函数的话会加大我们的计算时间。

因此宏相对于函数：

宏在程序的规模和速度更胜一筹（规模更小，运算更快）

不仅如此，宏的参数与类型无关

而宏较于函数的劣势处：

1. 每次使⽤宏的时候，⼀份宏定义的代码将插⼊到程序中。除⾮宏⽐较短，否则可能⼤幅度增加程序的⻓度。
2. 宏是无法调试的
3. 参数与类型无关，因此不够严谨
4. 可能带来运算符优先级问题，容易出错

但是宏却可以做到一些函数永远做不到的事——比如说参数中出现类型。

两者具体差异如下表所示：

7.#和##

#运算符

#可以理解为“字符串化”

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

示例如下：

##运算符

##可以理解为“联结符号”

## 被称为记号粘合，它可以把位于它两边的符号合成⼀个符号，它允许宏定义从分离的文本片段创建标识符。 这样的连接必须产⽣⼀个合法的标识符，否则其结果就是未定。

示例如下：

：

但是这样就有点麻烦了 一次求值就要写一个函数 因此我们可以换种方式写👇：

//假设我们要求两个数中的较大值
#define GENERIC_MAX(type) \
type type##_max(type x, type y)\
{ \
return (x > y ? x : y); \
}GENERIC_MAX(int)   //替换到宏体内后int##_max 生成了新的符号 int_max做函数名
GENERIC_MAX(float) //替换到宏体内后float##_max 生成了新的符号 float_max做函数名int main()
{//调用函数int m = int_max(2, 3);printf("%d\n", m);float f = float_max(3.5f, 4.5f);printf("%f\n", f);return 0;
}

这样子 我们就可以直接通过宏来求 而不用每次求不同类型的数据时都要写不同的函数。

8.#undef

移除一条宏定义

示例如下：

9.条件编译

简单来讲就是“满足条件就编译，不满足条件就不编译”。

像调试性的代码，删除可惜，保留⼜碍事，我们就可以选择性的编译。

示例如下：

其中#if 和 #endif就是条件编译语句。易知1 ！= 2 因此没有打印hehe。

10.头文件的包含

头文件的包含一般分为两种形式：

1. <······>   （如#include <stdio.h>）
2. "······"   （如#include "filename"）

前者为库文件包含，一般指标准库中头文件的包含。

查找头文件直接去标准路径下去查找，如果找不到就提⽰编译错误。
这样是不是可以说，对于库⽂件也可以使⽤" "的形式包含呢？——
答案是肯定的，可以是可以，但是这样做查找的效率就低些，而且这样也不容易区分是库⽂件还是本地文件了。

后者为本地文件包含，一般指自己创建的头文件的包含。

查找策略：先在源文件所在⽬录下查找，如果该头文件未找到，编译器就像查找库函数头文件⼀样在标准位置查找头⽂件。
如果还找不到就提⽰编译错误。

除了上述两种外，其实还有一种情况——嵌套文件包含

#include 指令可以使另外⼀个⽂件被编译，就像它实际出现于 #include 指令的
地⽅⼀样。
这种替换的⽅式很简单：预处理器先删除这条指令，并用包含⽂件的内容替换。
⼀个头⽂件被包含10次，那就实际被编译10次，如果重复包含，对编译的压⼒就⽐较⼤。

比如下面的代码：

#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
int main()
{return 0;
}

其中的十条#include "test.h"，在编译时都被test.h头文件中包含的内容替换了，导致编译压力较大。 这种情况就是嵌套文件包含。

那么我们该如何解决这些问题呢？——自然是用刚刚学的条件编译了。

1.每个头文件的开头写：

#ifndef __TEST_H__
#define __TEST_H__
//头⽂件的内容
#endif 
//__TEST_H__

2.或者

 #pragma once

这样就可以有效避免头文件的重复引入了。

11.其他预处理指令

#error
#pragma
#line
...
...

#pragma pack()  

我们还有很多其他的预处理指令，本文自然不可能给大家一 一讲完，大家可以自行去了解哦~

---

---

创作不易，如果作者写的还行的话给个免费的三连吧亲😙😙