C语言之预处理详解（完结撒花）

前言

        本文为我的C语言系列的最后一篇文章，主要讲述了#define定义和宏、#和##运算符、各种条件编译指令等，希望对大家有所帮助。

❤️感谢支持，点赞关注不迷路❤️

一、预定义符号

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

1. __FILE__ ：进行编译的源文件
2. __LINE__：文件当前的行号
3. __DATE__：文件被编译的日期
4. __TIME__：文件被编译的时间
5. __STDC__：如果编译器遵循 ANSI C ，其值为 1 ，否则未定义（VS不支持该符号）

演示：

#include <stdio.h>

int main()
{
	printf("%s\n", __FILE__);//进行编译的源文件
	printf("%d\n", __LINE__);//文件当前的行号
	printf("%s\n", __DATE__);//文件被编译的日期
	printf("%s\n", __TIME__);//文件被编译的时间

	return 0;
}

运行结果：

二、#define 定义常量

基本语法：

#define name stuff

• name：标识符名字，记住必须是连续的，不能有空格
• stuff：可以是数字，也可以是字符，它会在预处理阶段替换掉 name

演示：

#include <stdio.h>

#define M 100    //定义一个常量

int main()
{
	printf("%d\n", M);

	return 0;
}

运行结果：

解析：首先，该过程发生在编译与链接中的编译的预处理阶段，该过程会把定义的常量标识符直接替换成常量，如上，代码在预处理阶段就会把 M 替换成 100。

注意1：#define 定义后面不要加 分号，因为这个分号也会在预处理阶段替换掉标识符，这样就会多一个分号，导致编译报错

注意2：如果我们使用 #define 定义一个较长的符号时，我们需要换行时不能直接回车，而是需要用到续行符：\

如：

我们应该使用下面这种方式换行：

#define DEBUG_PRINT printf("file:%s\tline:%d\tdate:%s\ttime:%s\n" ,\
							__FILE__,\
							__LINE__,\
							__DATE__,\
							__TIME__)

切记：续行符 \ 后面要直接回车，不能有空格之类的东西。

三、#define定义宏

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

宏的声明：

#define name( parament-list ) stuff

• name：宏的名字
• parament-list ：参数表，传参的参数名
• stuff：宏实现的内容

注意：参数列表的左括号必须与name紧邻，如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。

举例：使用宏实现一个平方的计算

#include <stdio.h>

//定义一个宏
#define SQUARE(x) ((x)*(x))//括号是为了保证优先级

int main()
{
	int m = 0;
	scanf("%d", &m);

	int ret = SQUARE(m);
	printf("%d\n", ret);

	return 0;
}

运行结果：

解析：简单来说，宏就是把参数替换到 stuff 里，在预处理阶段，上述 int ret = SQUARE(m); 会被替换为 int ret = ((m)*(m)); ,然后在程序运行时被计算。

提问：为什么要使用那么多括号？

我们看以下场景：实现一个计算2倍的宏

#include <stdio.h>

//定义一个宏，假设不使用括号
#define DOUBLE(x) x+x

int main()
{
	int ret = 10 * DOUBLE(5 + 1);

	//进过预处理阶段，会变为以下形式
	//int ret = 10 * 5+1+5+1

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

	return 0;
}

运行结果：

解析：很明显这是一个错误的结果，怎么得到正确的结果呢，这就体现了括号的作用

以下为正确修改后的代码：

#include <stdio.h>

//定义一个宏，假设不使用括号
#define DOUBLE(x) ((x)+(x))

int main()
{
	int ret = 10 * DOUBLE(5 + 1);

	//进过预处理阶段，会变为以下形式
	//int ret = 10 * ((5+1)+(5+1))

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

	return 0;
}

运行结果：

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

宏的使用与函数有点类似，但是宏是没有类型检查的，它只是完成一个替换，适用于一些简单重复的功能的实现

带有副作用的宏参数

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

什么是副作用？例如：

1. y = x +1; // 不带副作用
2. y = x++; // 带有副作用

以上两种方式效果相同，可是第二种会修改 x 本身的值，这就是副作用。

MAX 宏可以证明具有副作用的参数所引起的问题：

#include <stdio.h>

//定义一个比较大小的宏
#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main()
{
	int a = 10;
	int b = 20;
	int c = MAX(a++, b++);

	//经过预处理阶段后，上一条代码会变为以下形式
	//int c = ((a++) > (b++) ? (a++) : (b++));

	printf("%d\n", c);
	printf("a=%d, b=%d\n", a, b);

	return 0;
}

运行结果：

解析：因为 宏 只是完成替换，所以上述 b 的值会被修改两次，但如果是函数的话，传入相同的参数，a和b只会被修改一次，因此我们使用宏的时候需要注意这些问题

宏替换的规则

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

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

注意：

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

四、宏与函数的对比

宏通常被应用于执行简单的运算。

比如在两个数中找出较大的一个时，写成下面的宏，更有优势⼀些。

#define MAX(a, b) ((a)>(b)?(a):(b))

函数：

int MAX(int a, int b)
{
	return a > b ? a : b;
}

那为什么不用函数来完成这个任务？

原因有二：

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜⼀筹。
2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之 这个宏怎可以适用于整形、长整型、浮点型等可以用于 > 来比较的类型。宏的参数是类型无关的。

和函数相比宏的劣势：

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

宏的参数可以出现类型，但是函数做不到。

例如：

#include <stdio.h>
#include <stdlib.h>

//定义一个宏用于申请空间
#define MALLOC(num, type) (type*)malloc(num * sizeof(type))

int main()
{
	int* p = MALLOC(10, int);
	//预处理阶段上述代码会转换为以下代码：
	//int* p = (int*)malloc(10 * sizeof(int));

	return 0;
}

宏和函数的一个对比：

五、#和## 运算符

1.# 运算符

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

#运算符所执行的操作可以理解为”字符串化“。

例如：我们有以下代码：

#include <stdio.h>

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

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

	float f = 6.6f;
	printf("the value of f is %.1f\n", f);

	return 0;
}

运行结果：

提问：上述用于打印 the value of a is 10 这串代码能否使用宏或者函数封装起来？

答案：使用宏可以，函数做不到。

函数为啥做不到呢？

void print(int a)
{
	printf("the value of a is % d\n", a);
}

原因：

1. 首先函数不能打印多类型数据
2. 其次，the value of a is 10，中的 a 是没办法替换的，我们的要求是 a 能根据参数名变化的。而函数中的 参数变量名  是跟字符没有联系的。因此函数做不到这一效果。

使用宏来实现：

首先我们需要了解 printf 的一个机制：

#include <stdio.h>

int main()
{
	printf("Hello World\n");
	printf("Hello"" World\n");

	return 0;
}

运行结果：

解析：如图和代码，printf 其实会自动拼接字符串，也就是说，printf 中有多个字符串，最终都会拼接成一条字符串输出打印。

根据 printf 的这条性质，加上 # 运算符可以把宏的一个参数转换为字符串字面量，我们就可以以下宏：

#include <stdio.h>

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

int main()
{
	int a = 10;
	PRINT("%d", a);
    //示例预处理之后的效果：
    //printf("the value of " "a" " is " "%d" "\n", n);

	int b = 20;
	PRINT("%d", b);

	float f = 6.6f;
	PRINT("%.1f", f);

	return 0;
}

运行结果：

2.## 运算符

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

比如：写一个函数求2个数的较大值的时候，不同的数据类型就得写不同的函数。

#include <stdio.h>

int int_max(int a, int b)
{
	return a > b ? a : b;
}

float float_max(float a, float b)
{
	return a > b ? a : b;
}

int main()
{
	printf("%d\n", int_max(3, 4));
	printf("%.1f\n", float_max(5.9f, 6.1f));

	return 0;
}

运行结果：

提问：如果只用函数，那么我们每次换个类型比较，就需要重新写一个对应类型的函数，有没有什么办法简化这一过程呢？

答案：有的，使用宏结合 ##运算符 就可以制作一个函数模版，简化这一过程

#include <stdio.h>

//宏定义, type##_max预处理之后将会合成一个符号
#define GENERIC_MAX(type) \
type type##_max(type x, type y)\
{\
	return (x > y ? x : y);\
}

//定义一个比较整形大小的函数
GENERIC_MAX(int) //注意不要加分号
//示例预处理之后：
//int int_max(int x, int y)
//{
//	  return (x > y ? x : y);
//}

//定义一个比较浮点型大小的函数
GENERIC_MAX(float)

//定义一个比较字符型大小的函数
GENERIC_MAX(char)

int main()
{
	printf("%d\n", int_max(3, 4));
	printf("%.1f\n", float_max(5.9f, 6.1f));
	printf("%c\n", char_max('a', 'b'));

	return 0;
}

运行结果：

提醒：在实际开发过程中##使用的很少，很难取出非常贴切的例子。主要是让我们看到别人这样写的时候我们能够看懂。

六、命名约定

一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者。

那我们平时的一个习惯是：

1. 把宏名全部大写
2. 函数名不要全部大写

七、#undef

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

#undef NAME
// 如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除。

示例：

#include <stdio.h>

//定义一个常量
#define M 100

int main()
{
	printf("%d\n", M);

//移除对M的宏定义
#undef M

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

	return 0;
}

运行结果：

八、条件编译

在编译一个程序的时候我们如果要将⼀条语句（一组语句）编译或者放弃是很方便的。因为我们有条件编译指令。

常见的条件编译指令：

1.#if #endif

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

功能：常量表达式成立，指向 #if 与 #endif 之间的所有代码，不成立则不执行

示例：

#include <stdio.h>

//定义一个常量
#define M 2

int main()
{
//条件指令，条件成立执行与 endif 之间的代码，否则不执行
#if M == 2
	printf("hello!\n");
#endif

	return 0;
}

运行结果：

注意：一定是常量表达式，不能是自己定义的变量，可以是#define定义的常量，因为变量是在程序编译后运行时生成的，而预处理指令是在预处理阶段执行的。

因为表达式为假不执行代码，所以可以用来注释多行代码：

#if 0

#include <stdio.h>

int main()
{
	printf("hello!\n");

	return 0;
}

#endif

2.多个分支的条件编译

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

功能：效果与if   else if   else相似，只不过是在预处理阶段执行且必须是常量表达式

示例：

#include <stdio.h>

//定义一个常量
#define M 4

int main()
{
#if M == 1
	printf("1\n");
#elif M == 2
	printf("2\n");
#elif M == 3 //#elif可以有多个
	printf("3\n");
#else
	printf("%d\n", M);
#endif

	return 0;
}

运行结果：

3.判断是否被定义

这两种效果一样，下面一种是简写

#if defined(symbol)
#ifdef symbol

功能：检查 symbol 是否用 #define 定义过。

#include <stdio.h>

//定义一个常量
#define M 4

int main()
{
#ifdef M
	printf("hh\n");
#endif

	return 0;
}

运行结果：

注意：同样要与 #endif 搭配使用

判断是否被定义还有一种相反的写法：

同样也有两种写法：

#if !defined(symbol)

#ifndef symbol

功能：用法相同，效果相反，判断是否没有被定义

示例：

#include <stdio.h>

int main()
{
#ifndef M
	printf("hh\n");
#endif

	return 0;
}

运行结果：

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

嵌套使用，与分支语句形式一样，这里不再举例

九、头文件的包含

1.头文件被包含的方式：

经常写头文件的朋友应该都知道，我们包含头文件的方式有两种，那么这两种包含方式有什么区别呢？答案：区别在于查找策略不同

1.本地文件包含

#include "filename"

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

2.库文件包含

#include <filename>

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

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

答案是肯定的，可以，但是这样做查找的效率就低些，当然这样也不容易区分是库⽂件还是本地⽂件了，所以不建议。

2.嵌套文件包含

首先我们要知道一个常识：就是如果没有任何指令的情况下，一个头文件被包含了多次，那么它就会被编译多次。也就是说如果一个头文件被包含10次，那就实际被编译10次，如果重复包含，对编译的压力就比较大。

如下：

test.h头文件：

void test();

struct  Stu
{
    int id;
    char name[20];
};

test.c：

 #include "test.h"
 #include "test.h"
 #include "test.h"
 #include "test.h"
 #include "test.h"

int main()
{
 
    return 0;
}

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

虽然实际中不会这样直接包含5次，当在一些多文件情况下，我们可能不得已间接包含多次，所以如何解决呢？答案：条件编译。

每个头文件的开头写：

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

解析：#ifndef __TEST_H__ 用于判断 __TEST_H__ 是否没有被定义，如果重复包含这里就会被判断已经被定义过，那么整个头文件内容将不会执行。如果没有定义，就 #define __TEST_H__ 定义一个该名称。用于下次判断。

当然还有一个简写的方法，使用VS的经常可以看到

#pragma once

我们在VS新建头文件时，编译器就会自动添加这项指令，该指令的作用就是防止头文件被重复包含

当然预处理指令不止这些，有兴趣的可以参考《C语⾔深度解剖》了解更多。

总结

        以上就是本文的全部内容了，感谢支持。