个人主页（找往期文章包括但不限于本期文章中不懂的知识点）：我要学编程(ಥ_ಥ)-CSDN博客

目录

预定义符号

#define 定义常量 

#define定义宏

带有副作用的宏参数 

宏替换的规则 

宏与函数的对比

#和## 

命名约定

#undef

命令行定义

条件编译 

头文件的包含 

预定义符号

C语言设置了一些预定义符号，可以直接使用，预定义符号也是在预处理期间被处理的。

__FILE__ //进⾏编译的源文件的路径

__LINE__ //⽂件当前的行号

__DATE__ //⽂件被编译的日期（月+日+年）

__TIME__ //⽂件被编译的时间（具体时间）

__STDC__ //如果编译器遵循ANSI C，其值为1，否则就是未定义的标识符

 我们下面就来打印看看结果。

#include <stdio.h>

int main()

{

printf("%s\n", __FILE__);

printf("%s\n", __DATE__);

printf("%s\n", __TIME__);

printf("%d\n", __LINE__);

return 0;

}

​

如果我们去打印__STDC__的话，就会发现VS2022会报错。

​

由此我们就可以得出一个结论：VS不是完全支持标准C。

#define 定义常量 

基本语法：

#define name stuff

我们通过例子来加深理解。 

#define MAX 1000

#define reg register //为 register这个关键字，创建⼀个简短的名字

//下面两个的做法不推荐

#define do_forever for(;;) //用更形象的符号来替换一种实现

#define CASE break;case //在写case语句的时候自动把 break写上。

//如果定义的stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠（续行符）。

#define DEBUG_PRINT printf("file:%s\tline:%d\t \

date:%s\ttime:%s\n" ,\

__FILE__,__LINE__ , \

__DATE__,__TIME__ )

在define定义标识符的时候，要不要在最后加上 ; 呢？答案是：最好不要加，否则容易出问题（就像下面这个例子一样）。 

​

​

加上；就报错的原因是if语句没加{ }时，后面只能跟一条语句，而MAX会被替换成

max = 1000；； 这也就意味着if语句后面跟了两条语句，并且没有加{ }，自然编译器会报错。所以我们在使用#define的时候不要在后面加上；

#define定义宏

#define 机制有一个规定，允许把参数替换到文本中，这种实现通常称为宏（macro）或定义宏 （define macro）。 下面是宏的申明方式：

#define name( parament-list ) stuff

//其中的 parament-list 是⼀个由逗号隔开的符号表（可以理解为参数），它们可能出现在stuff中。

//注意：参数列表的左括号必须与name紧邻，如果两者之间有任何空⽩存在，

//参数列表就会被解释为stuff的一部分

我们通过例子来加深理解。

​

​

但当我们要求3+1的平方时，按正常的结果算出应该是16，但是结果却是7。

​

这就牵扯到了运算符优先级的问题。SQUARE（3+1）经过预处理后的代码是 3+1*3+1，这就算出了结果7，因此为了避免这种问题我们就需要在有运算冲突的时候，加上括号（），来解决这种隐患。

​

注意：只要有#define定义的宏中存在运算符，我们就需要加上括号（）

突然发觉上面的变量a好像没啥作用（原谅我的懒惰，不想删了）

​

上面代码我们预期的输出结果是100，但是实际输出却是55，这同样是运算符优先级的问题。因此我们不能根据是加减就不加括号，只要是牵扯到运算符都要加上括号。

​

带有副作用的宏参数 

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

x+1;//不带副作用，没有改变x的值

x++;//带有副作用，改变了x的值

下面我们就根据示例来感受一下：

不带副作用：

​

带副作用：

​

我们先来分析一下这个代码：首先求出的最大值按照预期应该是没问题的，a++的结果是4，b++的结果是6，两个的最大值是6。上面这种理解是占在函数的角度去思考的（传参）。 而我们现在是要站在#define的角度去思考。首先，#define定义的宏是被替换展开的，即((a++)>(b++)?(a++):(b++))，这个过程再进行运算。在判断部分进行++， 再在结果部分进行++，因此虽然结果是6，但是过程却不一样。经过计算之后a的值4，但是b的值变成了7（a只在判断部分++，而b在判断部分，结果部分都进行了++）。

​

宏替换的规则 

在程序中扩展#define定义符号和宏时，需要涉及几个步骤。 1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。 2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。 3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果有，就重复上述处理过程。

注意： 1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。 2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索（如下图1）。

图1：

​

宏与函数的对比

 宏通常被应用于执行简单的运算。 比如在两个数中找出较大的一个数，写成宏，更有优势一些。 那为什么不用函数来完成这个任务？ 原因有二： 1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹。 2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之 宏可以适用于整形、长整型、浮点型等。宏的参数是与类型无关的。

和函数相比宏的劣势： 1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度地增加程序的长度。 2. 宏是没法调试的。 3. 宏由于与类型无关，也就不够严谨。 4. 宏可能会带来运算符优先级的问题，导致程容易出现错。 宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。

#define MALLOC(num, type)\

(type*)malloc(num*sizeof(type))

...

//使⽤

MALLOC(10, int);//类型作为参数

//预处理器替换之后：

(int*)malloc(10*sizeof(int));

#和## 

#运算符将宏的一个参数转换为字符串字面量。它仅允许出现在带参数的宏的替换列表中。 #运算符所执行的操作可以理解为“字符串化”。 当我们有一个变量 int a = 10; 的时候，我们想打印出： the value of a is 10 可以这样写：

​

但如果我们想要使用#define定义宏，用宏来直接打印该怎么办呢？这里就需要用到#，在使用#之前先来学习应一个小知识。

​

接下来就可以使用#来打印了

​

#a，是把a转换成"a"。

如果我们现在想把浮点数也给打印出来 ，就不是很难了。

​

这个数之所以这么大，是因为我们在取的时候是以%d的形式取的（不知道的小伙伴，可以看下面这篇文章： 数据在内存中的存储-CSDN博客）

因此C语言就给我们提供了##。

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

命名约定

⼀般来讲函数与宏的使用语法很相似。所以语言本身没法帮我们区分二者。 那我们平时的一个习惯是： 把宏名全部大写     函数名不要全部大写。

#undef

这条指令用于移除一个宏定义。

命令行定义

许多C语言编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。 例如：当我们根据同一个源文件要编译出一个程序的不同版本的时候，这个特性有点用处。（假定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器内存大些，我们需要一个数组能够大些。

#include <stdio.h>

int main()

{

int array[ARRAY_SIZE];

int i = 0;

for (i = 0; i < ARRAY_SIZE; i++)

{

array[i] = i;

}

for (i = 0; i < ARRAY_SIZE; i++)

{

printf("%d ", array[i]);

}

printf("\n");

return 0;

}

//linux 环境演⽰

gcc -D ARRAY_SIZE=10 programe.c

条件编译 

在编译一个程序的时候，我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件编译指令。比如说： 调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。

#include <stdio.h>

#define __DEBUG__

int main()

{

int i = 0;

int arr[10] = { 0 };

for (i = 0; i < 10; i++)

{

arr[i] = i;

#ifdef __DEBUG__ //如果定义了__DEBUG__就执行下面这条语句

printf("%d\n", arr[i]);//为了观察数组是否赋值成功。

#endif //与#ifdef对应

}

return 0;

}

常见的条件编译指令： 

1. 条件编译

//常量表达式由预处理器求值。

#if 常量表达式

//常量表达式的值为真，则下面的代码就会参与编译

//...

#endif

//例如：

#define __DEBUG__ 1

#if __DEBUG__ //结果为真，下面的代码会参与编译

//..

#endif

例如：

这个条件编译通常被用来”炫技“注释代码的。（ 我们掌握了这个之后也可以在别人面前装逼！哈哈哈！）

 2.多个分支的条件编译

//哪个表达式的结果为真，那么其后面的代码就会参与编译

#if 常量表达式

//...

#elif 常量表达式

//...

#else

//...

#endif

例如： 

3.判断是否被定义

//如果定义了symbol，其后面的代码就会参与编译

#if defined(symbol)

#ifdef symbol

//如果没有定义symbol，其后面的代码就会参与编译

#if !defined(symbol)

#ifndef symbol

例如： 

4. 嵌套指令

4.嵌套指令

#if defined(OS_UNIX)

#ifdef OPTION1

unix_version_option1();

#endif

#ifdef OPTION2

unix_version_option2();

#endif

#elif defined(OS_MSDOS)

#ifdef OPTION2

msdos_version_option2();

#endif

#endif

例如： 

头文件的包含 

本地文件的包含：#include "filename"。

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

Linux环境的标准头文件的路径：/usr/include

VS环境的标准头文件的路径：注意按照自己的安装路径去找。

库文件的包含：#include <filename.h>

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

嵌套文件的包含

我们已经知道， #include 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方一样。 这种替换的方式很简单：预处理器先删除这条指令，并用包含文件的内容替换。 一个头文件被包含10次，那就实际被编译10次，如果重复包含，对编译的压力就比较大。

如何解决头文件被重复引入的问题？答案：条件编译。

每个头文件的开头写：

#ifndef __TEST_H__

#define __TEST_H__

//头⽂件的内容

#endif

//或者

#pragma once

好啦！以上就是本期C语言之预处理详解的全部内容啦！我们下一期再一起学习吧！