C语言勘破之路-最终篇 —— 预处理(下)

人无完人，持之以恒，方能见真我！！！
共同进步！！

一、#和##

1.#运算符

这里的#不是#include和#define前面的那个#，它是一个运算符，这个运算符将宏的⼀个参数转换为字符串字⾯量，它仅允许出现在带参数的宏的替换列表中，#运算符所执⾏的操作可以理解为”字符串化“

在讲解这个运算符之前我们先来看一段代码，如下：

#include <stdio.h>

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

这里的第二个printf中的字符串由两个字符串组成，这样写和第一种printf的效果有什么不同呢

由此可以得出，如果两个字符串挨着一起写，会实现字符串的合并

为了讲清楚 # 运算符，我们先来看看这样一个例子，我们定义一个变量a = 3，然后我们想要在屏幕上打印 the value of a is 3,经过上面那个例子，我们就可以像下面这样做

int a = 3;
printf("the value of a is %d\n",a);

这个时候我们随便更改a的值都可以使得这句话是正确的，它会随着a的改变而改变，然后我们这个时候说，再创建几个变量，也要以这种形式进行打印，那么每打印一次我们都要写这么长的一串，有没有什么办法简化一下呢？

这里我们就可以用宏来解决，在上面那个字符串中，有三个变化的地方，一个就是of后面的a，还有就是占位符%d，然后就是最后面的a，那么我们就可以定义一个宏PRINT，它的参数就是我们要打印的那个值和占位符，如下：

#define PRINT(x , format) printf("the value of x is %d\n",x);

首先我们写出来这个宏后可以发现最后面的那个x会随着我们提供的变量变化，所以已经解决了，还有两个地方要处理，就是of后面的x和后面的占位符，因为它们都在字符串中，所以替换的时候不会替换它们，那么我们怎么办呢

对于占位符的替换，我们可以使用上面学习的两个字符串可以合并的思想，如下：

#define PRINT(x , format) printf("the value of x is "format"\n",x);

这样，前面的the value of x is 就变成一个字符串，后面的\n也变成了一个字符串，这个时候只需要我们传参的时候传上我们的占位符就可以了，如下：

int a = 3;
PRINT(a, "%d");

经过传参后format会被替换成"%d"，又是一个字符串，前面一个，中间一个，后面一个字符串，最后合并成了一个字符串

然后就是最后一个要解决的问题，就是of后面的x，我们怎么能够使得它随着我们的传参变化而变化呢？这个时候就要请出我们的#运算符了，它可以使得宏的参数字符串化，只需要将x左右的字符串分开，然后在它前面加上#即可，如下：

#define PRINT(x , format) printf("the value of "#x" is "format"\n",x)

这里将原本的参数x字符串化了，最后也变成了一个字符串，和其它几个字符串合并在了一起，但是这个时候x的内容就会随着我们的传参改变而改变了，比如把变量a传给x，那么of后面就是a，把变量b传给x，那么of后面就是b

#include <stdio.h>

#define PRINT(x , format) printf("the value of "#x" is "format"\n",x)

int main()
{
	int a = 3;
    float b = 5.1f;
	PRINT(a, "%d");
	PRINT(b, "%f");
	return 0;
}

这样我们就使用#运算符实现了参数的字符串化，#运算符基本上用不到，但是我们还是可以当做扩展来了解一下

2.##运算符

##运算符又是一个完全不同的运算符了，#运算符的作用是是参数字符串化，##运算符则是可以把位于它两边的符号合成⼀个符号，它允许宏定义从分离的⽂本⽚段创建标识符。##被称为记号粘合运算符

比如有一个变量class108，我们就可以通过class和108的粘合来得到

现在我们就来使用class108这个来举个例子，我们定义一个宏，它的作用就是帮我们合并两个符号，如下：

#define CAT(x,y) x##y

CAT这个宏就可以帮助我们粘合我们传过去的参数x和y，比如我们传参class和108，那么它就可以帮我们合并成class108

CAT(class,108);
//经过预处理后变成
class108

我们现在写一段代码测试一下，看看它能否实现我们的要求：

#include <stdio.h>

#define CAT(x,y) x##y

int main()
{
	int class108 = 5;
	printf("%d\n", CAT(class, 108));
	//这里CAT(class,108)相当于class108
	//因为CAT的作用就是粘合两个符号
	//这句话就变成了printf("%d\n",class108)
	//会直接打印5
	return 0;
}

我们就以求最大值这个函数为例，当我们要找出两个整型数据的最大值时，我们需要一个函数，当我们要找出两个浮点型数据的最大值时，又需要一个函数来实现，但是其实这两个函数的实现内容是非常一致的，如下：

int int_max(int x, int y)
 {
 return x>y?x:y;
 }
 
 float float_max(float x, float y)
 {
 return x>yx:y;
 }

现在我们就来写一个宏，宏名为：GENERATE_MAX，这个宏的作用就是，根据我们传过去的数据类型，自动生成一个找两个数据中最大值的函数，它们的形式类似于：类型_max，这个时候我们就可以用到我们的##运算符，如下：

#define GENERATE_MAX(type) \
type type##_max(type x, type y) \
{\
    return x>y?x:y; \
}

上面就是我们写出的创建函数的宏，它可以根据参数type来确定函数名和函数类型，其中的\是续航符，可以使内容看起来隔开了，实际上是连贯起来的

这里我们也使用到了##运算符，如果我们单纯写一个type_max，那么在处理时会把它当作一个整体，每次我们创建的函数名就都是type_max了，而不会根据type的变化生成不同的函数名

而如果我们使用了##运算符就可以使得type成为一个独立的参数，而后面的_max就是粘合的符号，这样type这个类型在变化，函数名也就可以跟着一起变化了

现在我们就使用这个宏来分别创建一个比较整型最大值和浮点型最大值的函数，如下：

GENERATE_MAX(int)
GENERATE_MAX(float)

我们将鼠标指向这个宏，随后我们就可以看到我们使用这个宏后会发生什么，可以看出来这两条语句经过处理后会替换成两个函数

那我们就举个例子来验证我们的代码是否可以实现

#include <stdio.h>

#define GENERATE_MAX(type) \
type type##_max(type x, type y) \
{\
    return x>y?x:y; \
}

GENERATE_MAX(int)
GENERATE_MAX(float)

int main()
{
	int a = 4;
	int b = 5;
	float c = 5.3f;
	float d = 6.2f;
	int ret1 = int_max(a, b);
	float ret2 = float_max(c, d);
	printf("%d %f\n", ret1, ret2);
	return 0;
}

运行结果

所以这些符号的运用也是有很多的乐趣，学习之余，我们也可以多多了解一些有趣的知识

二、预处理指令#undef

#undef指令的作用是移除一个#define的定义，它的使用格式如下：

#undef NAME

其中的NAME就是我们要移除的宏的名称，当我们想要更换一下宏名的定义时，就可以使用#undef指令先移除它原本的定义，然后再重新定义它，如下：

#include <stdio.h>
#define N 100

int main()
{ 
	printf("%d\n", N);
#undef N
#define N "hello"
	printf("%s\n", N);
	return 0;
}

这里我们首先使用#define将N定义为了100，将它打印后我们想要改变它的定义，就使用#undef把它原本的定义移除，然后将它重新定义成了一个字符串，然后再重新打印

三、条件编译

条件编译有点类似于我们的分支语句，不过条件编译是在预处理阶段进行的，它会根据我们的条件来决定是否编译某些语句，接下来我们就来学习条件编译

1.单分支条件编译

单分支条件编译就是我们只有一条分支需要进行条件判断，使用格式如下：

#if  常量表达式
//如果条件为真那么就编译这里的语句
//如果条件为假就不会编译这里的语句
#endif
//结束的标志

可以看到单分支条件编译从#if开始，然后再#endif结束，它和分支语句类似，但是它有一个结束标志，就是#endif，这是分支语句中没有的

如果条件为真，那么就会编译中间的语句，也就是说最后会执行那些语句，如果为假则不会执行，但是这个条件需要一个常量表达式，我们等下来解释为什么不能使用变量，现在我们可以先来测试一下#if和#endif，如下：

#include <stdio.h>

#define N 5

int main()
{
#if N == 6
	printf("hello\n");
#endif
	return 0;
}

这里什么也不会打印，因为我们定义的N是5，这里当然不等于6，所以不会编译语句printf(“hello\n”)，也就不会执行它

如果条件编译的结果为假，那么条件编译中的语句经过预处理后会被直接删除，就像我们的注释一样，也是经过预处理后直接删除，所以后面编译就不会带上条件编译中的语句，最后运行生成的可执行程序也就不会执行这段语句

现在我们再回到之前的那个问题，为什么#if后面必须跟一个常量表达式，不能是变量呢？这是因为#if是在预处理阶段进行处理的预处理指令，在预处理阶段还没有给变量分配空间，也就是变量在这个阶段都不存在，自然不能使用变量了，只能使用常量

2.多分支条件编译

多分支条件编译也与分支语句中的多分支语句原理差不多，我们来看看在多分支条件编译中需要用到哪些语句：

#if 常量表达式
//...
#elif 常量表达式
//...
#else
//...
#endif
//...

这里我们列出的结构就是多分支条件编译的结构，这样看有点陌生，我们拿分支语句中的多分支语句跟它们进行一一对应，来进行类比学习：

#if -- if
#elif -- else if
#else -- else
#endif -- 分支语句中没有，是条件编译结束的标志

这样看是否就简单多了，它们的用法都差不多，只是条件编译在预处理阶段进行处理，不能使用含变量的表达式，我们现在就来看一个例子，看看它的结果是什么，如下：

#include <stdio.h>

#define N 10

int main()
{
#if N == 5
	printf("hehe\n");
#elif N == 10
	printf("haha\n");
#else
	printf("hello\n");
#endif
	return 0;
}

这里很好理解，就是谁满足条件，就执行谁

3.判断符号是否被定义

在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码

在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行

在实现这个功能之前，我们先来学习如何判断一个符号是否被定义，有两种方式：

1. 使用#if defined进行判断：从字面意思来也很容易理解，判断符号是否已经被定义，它的使用格式如下：

#if defined(符号)

2. 使用#ifdef进行判断：#ifdef实际上就是#if defined的缩写，只是缩写后它的使用方法有点不同，如下：

#ifdef 符号

在使用#ifdef就不再需要小括号了，而是直接在后面写上我们要判断是否被定义过的符号

现在我们学习了如何判断一个符号是否被定义过，现在就来实现一下上面的我们提出的功能，首先我们定义一个符号DEBUG来表示调试，当我们注释掉它的时候，调试信息跟着一起不会执行了

我们现在就引入一个场景，使用循环往数组里面存放信息，为了保证我们往数组里存放数据成功了，我们每存放一次数据就将它打印一次，这个打印就是我们的调试信息，为了检查我们是否成功往数组存放信息的调试性代码

现在我们就来看这样一个场景，如何使用#ifdef或者是#if defined，如下：

#include <stdio.h>

#define DEBUG
//debug的意思是调试

int main()
{
	int arr[5] = { 0 };
	for (int i = 0; i < 5; i++)
	{
	//往数组存放数据
		arr[i] = i + 1;
#ifdef DEBUG//等价于#if defined(DEBUG)
   //打印一下数据，看看数据是否存放进去了
		printf("%d ", arr[i]);
#endif
	}
	return 0;
}

如果我们定义过DEBUG这个符号,那么就会执行打印语句，这里我们定义了DEBUG这个符号，那么代码就会编译中间的调试性语句

如果我们注释它，就不会运行打印了

4.判断符号是否没有被定义

这里我们就简单介绍一下判断符号是否没有被定义的两个方法，不再举例了，因为它和上面的判断符号是否被定义用法差不多

1. 使用#if !defined：这个条件编译语句就是在上面我们讲过的#if defined的defined前加上一个！，表示否定，所以这个条件编译语句就是判断符号是否没有被定义，格式还是和#if defined一致，这里就不再赘述了

2. 使用#ifndef：这个条件编译语句就是在上面我们讲过的#ifdef的def前面加上一个n，表示no，也是否定含义，所以这个条件编译语句就是判断符号是否没有被定义，格式还是和#ifdef一致，这里就不再赘述了

四、头文件的包含

头文件的包含的本质就是拷贝，当我们包含一个头文件后，会直接将头文件的内容拷贝过来，接下来我们就来学习头文件的包含方式，以及嵌套包含头文件时，如何解决代码冗余的问题

1.库头文件的包含

库头文件里面包含了C语言帮我们实现的功能，我们只需要包含库头文件就可以使用相应的功能和函数，如标准输入输出头文件stdio.h，我们在包含这种库头文件时，一般会使用尖括号<>来进行包含，如下：

#include <stdio.h>

当我们使用<>来进行包含头文件时，程序会直接去我们IDE的标准路径下去查找，如果找不到就提示编译错误

2.本地头文件的包含

本体头文件就是我们自己写的头文件，比如add.h，这种手动实现的头文件，我们在包含这种本体头文件时常常使用双引号""来进行包含，如下：

#include "add.h"

那么程序就会先在源⽂件所在⽬录下查找，如果该头⽂件未找到，编译器就像查找库函数头⽂件⼀样在标准位置查找头⽂件

那么问题来了，我们可不可以使用双引号"“这种方式来包含库头文件，答案是可以，那么为什么我们还要使用<>来包含库头文件，而不是统一使用双引号来包含头文件

如果使用”“包含库头文件，那么每次都要去当前文件夹里找这个头文件，但是我们知道实际上不可能找得到，然后再去标准路径找这个头文件，我们平常使用的头文件较少，可能影响不大， 但是在大型工程中，这多余的步骤将会造成不小的开销，多余的开销就会影响工程的进度，影响我们赚钱的速度

所以我们还是要养成良好的习惯，包含库头文件使用尖括号<>，包含本地头文件使用双引号”"

3.嵌套包含头文件的解决方法

在最开始我们提到了，我们包含头文件的本质就是进行代码的拷贝，将头文件的所有内容拷贝进我们的源文件，那么我们如果嵌套包含，也就是可能多次包含了同一个头文件多次，势必会造成代码的冗余

我们先来看看包含一个头文件多次可能的场景，如图：

在上图场景中，我们每个功能实现都包含了头文件add.h，最后进行汇总时势必会包含三次头文件add.h，造成代码的冗余

就拿最常使用的头文件stdio.h来举例，我们来看看这个库头文件有多少行代码

方法就是正常包含头文件stdio.h，然后使用ctrl加单击的方法就可以点进这个头文件了，我们拉到最后发现它居然有两千多行代码

那么如果此时我们多次包含了这个头文件，势必会造成代码冗余,就根我上面说的一样，不必要的开销会影响我们赚钱的速度

使用条件编译指令

我们可以使用刚刚学习的条件编译指令解决，具体就是#ifndef或者#if !defined这两个指令，简单好用还好写

由于头文件的包含就是代码的拷贝，所以我们可以根据这个特点来设计一个功能，就是：一旦包含头文件，我们就判断是否定义了某个符号，如果没有定义我们就定义一下它，然后执行后面的头文件包含，如果这个符号已经被定义了那么就跳过头文件的包含不执行，如下：

 #ifndef __TEST_H__
 #define __TEST_H__
 //头⽂件的内容
 
#endif   //放到头文件最后

这就是我们避免头文件嵌套包含的第一种方法

使用预处理指令#pragma

这种方法就更为简单了，我们可以在VS2022上创建一个头文件，我们发现头文件中自动包含了一条语句

我们可以看到，一创建头文件，这条语句就出现了，这就是今天要介绍的第二个方法，在头文件开头写下预处理指令#pragma once，那么就可以解决头文件嵌套包含的问题，是不是特别简单呢？

当然，在VS上帮我们自动写上这条指令了，如果在其它编译器上创建头文件没有这条语句，那么我们直接加上就可以了，也十分简单

五、其它预处理指令

如果还想要学习更多的预处理指定就需要大家自己去自行了解了，这里我就推荐一本书，想要深入学习预处理指令就可以参考一下这本书：《C语⾔深度解剖》

六、C语言勘破之路结语

一路走来，我们的C语言终于走到了结尾，相信大家也是收获多多吧，接下来就是我们的初阶数据结构的学习了，博主会与大家一起成长的！！

从下一篇文章我们就开始学习数据结构了，在里面我们会手动实现那些数据结构，可以体会到二级指针和递归的暴力美学，狠狠期待一下吧！

那今天就这样完美的给我们的C语言画上一个句号吧，bye~~ 各位