【C语言学习】预处理详解

一、预定义符号

C语言设置了一些预定义符号，可以直接使用，预定义符号也是在预处理期间处理的。
FILE //进行编译的源文件
LINE //文件当前的行号
DATE //文件被编译的日期
TIME //文件被编译的时间
STDC //如果编译器遵循ANSI C，其值为1，否则未定义

注：VS 2022暂时不支持__STDC__

Windows环境，VS编译器：

c 复制代码

#include <stdio.h>

int main()
{
	printf("%s\n", __FILE__);
	printf("%d\n", __LINE__);
	printf("%s\n", __DATE__);
	printf("%s\n", __TIME__);
	return 0;
}

运行结果：

Linux环境，gcc编译器：

二、#define定义常量

Linux环境，gcc编译器：

在define定义的时候，末尾不用加;
原因：;会被当成一个整体，带入程序中，比如，#define M 100; M会被展开成100;，如果打印M：printf("%d", 100;);就会出现语法错误。

有时候，将地址写入程序会存在地址过长，也可通过#define定义常量。

c 复制代码

#define DEBUG_PRINT printf("file:%s\tline:%d\t \date:%s\ttime:%s\n", \__FILE__, __LINE__,__DATE__, __TIME__)
//地址写一行太长
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
					date:%s\ttime:%s\n", \
					__FILE__, __LINE__,\
					__DATE__, __TIME__)
//写2行有会出问题
//每一行结尾加上\（续航符），如果有空格，在空格后面加
int main()
{
	DEBUG_PRINT;
	return 0;
}

三、#define定义宏

#define机制包括一个规定，允许把参数替换到文本中，这种实现称为宏或者定义宏。

比如，Linux环境下，利用gcc编译器，定义一个宏来实现平方：

在预编译时，程序中，SQUARE(a)被替换成a*a。

宏容易出现的问题：

c 复制代码

#include <stdio.h>

#define SQURE(x) x*x

int main()
{
	int a = 10;
	int r = SQURE(a+1);
	printf("%d\n", r);
	return 0;
}

运行结果：

按照我们理解，SQUARE(a+1)应该是(a+1)(a+1),1111结果是121。但是结果为什么是21呢？
在预处理阶段，SQUARE(x)替换成x*x的形式，但是括号里面是不会先进行计算的。也就是说，SQUARE(a+1)会替换成a+1*a+1。

Linux环境下，gcc编译器：

代码修改：

c 复制代码

#include <stdio.h>

#define SQURE(x) (x)*(x)

int main()
{
	int a = 10;
	int r = SQURE(a+1);
	printf("%d\n", r);
	return 0;
}

运行结果：

Tips：用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用。

四、带有副作用的宏参数

c 复制代码

//写一个宏，求2个数的较大值
#include <stdio.h>

#define MAX(x,y) x>y?x:y

int main()
{
	int a = 10;
	int b = 20;
	int m = MAX(a++, b++);//宏的使用和函数类似
	printf("m = %d\n", m);
	printf("a = %d\n", a);
	printf("b = %d\n", b);
	return 0;
}

运行结果：

原因：

先执行(a++)>(b++)（a = 10，b = 20），执行完后再执行a++、b++（a = 11，b = 21）；显然10 > 20为假，后面执行b++，在这之前，把b = 21赋给m，赋值后，再b++（b = 22）。所以最终的结果是m = 21，a = 11，b = 22。

五、宏替换规则

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

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

六、宏和函数对比

宏和函数都能实现比较大小：

c 复制代码

#include <stdio.h>
#define MAX(x,y) x>y?x:y

int MaX(int x, int y)
{
	return x > y ? x : y;
}

int main()
{
	int a = 10;
	int b = 20;
	int m = MAX(a, b);//宏的使用和函数类似
	printf("m = %d\n", m);
	int m2 = MaX(a, b);
	printf("m2 = %d\n", m2);
	return 0;
}

#define MALLOC(n,type) (type*)malloc(n*sizeof(type))

int main()
{
	int* p = MALLOC(10, int);
	return 0;
}

运行结果：

宏和函数处理方式不同：

Linux环境，gcc编译器：

如何选择使用宏还是函数？

属性	#define定义宏	函数
代码长度	每次使用，宏代码都会插入程序中。除了非常小的宏之外，程序长度会大幅增加	函数代码只出现于一个地方；每次调用函数，都调用那个地方的同一份空间
执行速度	更快	存在函数的调用和返回的额外开销，会慢一些
操作符优先级	宏参数的求值是在所有周围表达式的上下文环境里，除非加上括号，否则邻近操作符的优先级可能会产生不可预料的后果，所以建议宏在书写时多写一些括号	宏参数只在函数调用的时候求值，结果值传递给函数。表达式求值预测。
带有副作用的参数	参数可能会被替换到宏体的多个位置，如果宏的参数被多次计算，带有副作用的参数求值可能会产生不可预料的后果	函数参数只在传参的时候求值，一般不易控制
参数类型	宏的参数与类型无关，只要对参数的操作是合法的，他就可以使用于任何参数类型	函数的参数是与类型有关的，如果不同，就需要不同的函数，及时任务是不同的
调试	宏是不方便调试的	函数是可以逐句调试的
递归	宏是不能递归的	函数是可以递归的

七、#和##运算符

7.1 #运算符

#运算符将宏的一个参数转换为字符串字面量。它仅允许出现在带参数的宏的替换列表中。#运算符所执行的操作可以理解为"字符串化"。

c 复制代码

//#运算符
#include <stdio.h>

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

int main()
{
	/*printf("hello world\n");
	printf("hello ""world");*/

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

	float f = 3.14f;
	//printf("the value of a is %f\n", f);
	
	PRINT(a, "%d");
	PRINT(f, "%f");
	return 0;
}

运行结果：

我们发现printf("the value of a is %d\n", a);、printf("the value of f is %d\n", a);有很多共同点。将它们封装到一个宏里面，但是中间那个字符n无法直接转化成a或者f，需要借助#运算符。

7.2 ##运算符

##可以把位于它两边的符号合成一个符号，它允许宏定义从分离的文本片段创建标识符。##称为为记号粘合。

Linux环境下，gcc编译器：

八、命名约定

函数和宏的使用语法很相似。所以语言本身没法帮我们区分二者。我们约定：所有字母大写是宏，首字母大写是函数。

九、#undef

#define是定义宏，#undef是取消定义宏

c 复制代码

#include <stdio.h>

#define M 100

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

运行时报错：

十、命令行定义

许多C的编译器提供了⼀种能力，允许在命令行中定义符号。用于启动编译过程。

Linux环境下，gcc编译器为例：

十一、条件编译

编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃，需要用到条件编译指令。

c 复制代码

#include <stdio.h>
#define __DEBUG__

int main()
{
    int i = 0;
    int arr[10] = { 0 };
    for (i = 0; i < 10; i++)
    {
        arr[i] = i;
#if undef __DEBUG__
        printf("%d\n", arr[i]);//为了观察数组是否赋值成功。
#endif //__DEBUG__
    }
    return 0;
}

运行结果：

定义__DEBUG__，条件为真，打印数组；没有定义__DEBUG__，条件为假，没有打印。

11.1 常量表达式

c 复制代码

#include <stdio.h>

int main()
{
#if 1//这里必须要是常量，不能是变量
	printf("hehe\n");
#endif
	return 0;
}

运行结果：

11.2 多个分支的条件编译

c 复制代码

#include <stdio.h>

int main()
{
#if M > 0
	printf("hehe\n");
#elif M >10
	printf("haha\n");
#elif M == 100
	printf("呵呵\n");
#else
	printf("哈哈\n");
#endif
	return 0;
}

运行结果：

遇到多个分支，只执行一个分支。

11.3 判断是否被定义

c 复制代码

#include <stdio.h>

int main()
{
//#if defined(M)
//#ifdef M//和上面是等价的
#if defined(M)
	printf("hehe\n");
#endif

	return 0;
}

运行结果：

十二、条件编译---头文件的包含

12.1 头文件被包含的方式

12.1.1 本地头文件包含

#include "stdio.h"

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

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

VS环境的标准头文件的路径：C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include（VS默认路径）

12.1.2 库头文件包含

#include <filename.h>

查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。

是不是可以说，对于库文件也可以使用""的形式包含？

答案是肯定可以的，但是这样做查找的效率就低些，也不容易区分是库文件还是本地文件。
问：<>和""的差别是什么？
答：""需要查找两次，先在源文件所在目录下查找，找不到的话，再和库文件一样，在标准位置（编译器安装目录）查找，这种查找方式主要针对自定义的文件。<>则是查找库头文件，只查找一次。

12.2 嵌套文件包含

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

如果直接这样写，test.c文件中将test.h包含5次，那么test.h文件的内容将会被拷贝5份在test.c中。如果test.h文件比较大，这样预处理后代码量会剧增。如果工程比较大，有公共使用的头文件，大家都能使用，又不做任何的处理，那么后果真的不堪设想。如何解决头文件被重复引用的问题？答案：条件编译。

Linux环境下，gcc编译器中：