【C语言】程序环境和预处理

🌠作者：@阿亮joy.
🎆专栏：《学会C语言》
🎇座右铭：每个优秀的人都有一段沉默的时光，那段时光是付出了很多努力却得不到结果的日子，我们把它叫做扎根

👉程序的翻译环境和执行环境👈

在ANSI C标准的任何一种实现中，存在两个不同的环境。

第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。
第2种是执行环境，它用于实际执行代码。

👉详解编译和链接👈

翻译环境

• 组成一个程序的每个源文件通过编译过程分别转换成目标代码（object code）。
• 每个目标文件由链接器（linker）捆绑在一起，形成一个单一而完整的可执行程序。
• 链接器同时也会引入标准C函数库中任何被该程序所用到的函数，而且它可以搜索程序员个人的程序库，将其需要的函数也链接到程序中。

一、编译的几个阶段

编译分为三个阶段，分别为预编译（预处理）、编译和汇编。如下图所示：

那在这三个阶段里，编译器究竟会做什么处理呢？接下来，我们来学习一下。

1.预处理

• 完成头文件的包含（#include）
• #define 定义的符号和宏的替换
• 注释的删除

因为在 VS2022 上无法看到预编译、编译和汇编的过程，所以我们就在 Linux 环境下测试我们的代码。

我们在 Linux 系统下创建一个 test.c 的代码（相关的指令，大家可以自行搜索学习），然后输入指令gcc test.c编译test.c代码（gcc 是一个编译器），编译完成结束会在该目录下生存一个可执行程序 a.out（相当于 Windows 系统下的.exe文件）。通过指令ls可以查看该目录下的全部文件，可以看到确实是生成了一个a.out文件。再然后输入指令./a.out就可以看到程序运行的结果了。

有小伙伴就说了，这也没有看到所谓的预处理过程啊。不要着急，这只是在给大家介绍一下如何在 Linux 环境下编译和执行我们写的代码。接下来，我们就来学习一下预编译的过程。

• 完成头文件的包含（#include）

刚才我们已经写了一个代码test.c，现在我们就对这个代码进行预编译。首先我们输入指令gcc test.c -E，这条指令的意思是预编译完成后就停止，不在执行往后的编译和汇编，也不会生成可执行程序a.out。输入完gcc test.c -E指令后，在命令行里会出现很多的信息，其实这就是头文件的包含。

如果想要不在命令行出现这些信息，我们可以将指令gcc test.c -E换成指令gcc test.c -E >test.i（输出重定向），它就会生成一个test.i的文件，文件中保存着预处理后产生的信息。我们也可以通过ls指令看是否真的生成test.i文件，也可以打开该文件看到预处理后产生的信息。

如果我们想要看到stdio.h头文件的内容，首先我们先进入到stdio.h头文件所在的路径（输入指令cd /usr/include/），然后通过指令nano stdio.h就可以查看头文件的内容了。


通过这样一对比，我们就可以知道，头文件的包含其实就是将头文件里的内容拷贝到代码中去。

• #define 定义的符号和宏的替换

为了看到 #define 定义的符号和宏的替换的效果，我们就打开我们的代码，修改一下我们的代码。

我们现在输入指令gcc test.c -E >test.i进行预处理，然后打开生成的test.i文件查看预处理后产生的信息。见下图：

通过对比test.c代码和预处理之后的信息，我们可以清晰地看到预处理完成了 #define 定义的符号和宏的替换。因为在预编译的过程已经完成了 #define 定义的符号和宏的替换，所以在往后的编译、汇编和调试的时候，我们都无法看到 #define 定义的符号和宏了。

• 注释的删除

为了看到注释的删除的效果，我们在原来的代码上加上一段注释，对比一下代码和预处理后产生的信息，就可以明显地看到注释的删除。

以上就是预处理的主要过程，预处理中的这些操作都是一些文本操作。接下来我们学习一下编译，看一下编译过程究竟是如何的。

2.编译

预处理完后生成了一个 test.i 的文件，接下来我们就要对该文件进行编译处理。在编译处理的过程中，会文件做语法分析、词法分析、语义分析和符号汇总的操作。

知道了这些，我们就输入指令gcc test.i -S对test.i文件进行编译处理，并且输入该指令后会生成一个test.s的文件。当然，我们同样可以输入指令ls查看是否真的生成了test.s文件。

那test.s文件中都有什么内容呢？现在我们通过指令nano test.i来查看一下test.s文件的内容。

我们发现，test.s文件里面的内容我们好像也看不懂诶。其实test.s里面放的就是我们写的代码所对应的汇编代码。其实，编译的过程就是将C语言代码转化成汇编代码。在这个过程中，编译器就会对代码进行语法分析、词法分析、语义分析和符号汇总。如果大家对这些编译过程感兴趣的话，可以看一下《编译原理》这本书或者自行搜索。在《编译原理》这本书里，主要将的是如何实现一个编译器和编译器的工作原理。对于符号汇总，我们将会在下面的内容里讲解一下。

3.汇编

汇编过程就是将汇编指令转换成机器指令（二进制指令）的过程。与此相反的是反汇编，反汇编是将机器指令（二进制指令）转换成汇编指令的过程。关于汇编语言，对于一个程序员来说，也是非常地重要的。如果大家感兴趣的话，也可以自行学习一下，增加自己的内功，让自己深入了解计算机究竟是如何工作的。那么，接下来我们就来学习一下汇编过程。

在汇编过程里，我们所要使用的指令是gcc test.s -c。输入指令gcc test.s -c后，会生成一个test.o的文件（Linux 系统的目标文件，Windows 系统的目标文件是.obj后缀）。

那现在，我们也打开test.o文件，看一下他里面的内容。

因为test.o文件里的内容都是一些机器指令（二进制指令），所以我们就更加看不懂了。虽然我们看不懂，但是有一个工具readelf可以看懂，因为test.o文件是elf格式的。elf格式将test.o文件划成了一个一个的段，不同的段里存储的数据是不一样的。

接下来，我们可以输入指令readelf test.o -s来看一下test.o文件的内容。

在汇编过程中，除了将汇编指令转换成机器指令（二进制指令）外，还生成了符号表。上图红色框框框住的就是汇编过程中生成的符号表。

为了更好地理解上面的全过程，博主再给出一个例子。

那生成的符号表有什么用呢？学习了接下来的链接，你就会知道了。

二、链接

链接过程主要做的是把多个目标文件（.o文件）和链接库进行链接，然后生成可执行程序a.out。那链接过程具体又做了什么呢？链接过程中主要做了两件事：1.合并段表；2.符号表的合并和重定位。

1.合并段表

在编译过程中，生成了多个目标文件，也就有了多个段表。那么在链接的时候，我们就需要把相同段的数据合并，然后生成可执行程序a.out。

2.符号表的合并和重定位

在汇编的时候，会生成多个符号表。那么在链接的时候，我们就需要对符号表进行合并和重定位，将无效的符号地址去除，有效的符号地址保留下来。那么通过有效的符号地址就可以找到相关的函数。

如果你将add.c文件里的Add函数的定义给注释掉了，那么在链接的时候就会出错。

以上就是翻译环境所需要做的全部事情，接下来我们来学习一下运行环境。

运行环境

程序执行的过程：

1. 程序必须载入内存中。在有操作系统的环境中，一般这个由操作系统完成。在独立的环境中，程序的载入必须由手工安排，也可能是通过可执行代码置入只读内存来完成。

2. 程序的执行便开始。接着便调用main函数。

3. 开始执行程序代码。这个时候程序将使用一个运行时堆栈（函数栈帧）（stack），存储函数的局部变量和返回 地址。程序同时也可以使用静态（static）内存，存储于静态内存中的变量在程序的整个执行过程 一直保留他们的值。

4. 终止程序。正常终止main函数；也有可能是意外终止。

对函数栈帧的创建与销毁感兴趣的话，可以看一下博主之前写的文章：【C语言】函数栈帧的创建和销毁详解。这一块内容也是非常重要，相信大家看了之后，一定会有不少的收获。在此就不赘述这一块内容了。

详解编译和链接全过程图片

👉预处理详解👈

预定义符号

• __FILE__ //进行编译的源文件
• __LINE__ //文件当前的行号
• __DATE__ //文件被编译的日期
• __TIME__ //文件被编译的时间
• __FUNCTION__ //文件当前所在的函数
• __STDC__ //如果编译器遵循ANSI C标准，其值为1，否则未定义

这些预定义符号都是语言内置的，那有什么呢？通过下面的程序我们来看一下。

#include <stdio.h>
int main()
{
	printf("%s\n", __FILE__);
	printf("%d\n", __LINE__);
	printf("%s\n", __DATE__);
	printf("%s\n", __TIME__);
	printf("%s\n", __FUNCTION__);
	return 0;
}

还有一个内置的预定义符号，需要编译器遵循ANSI C标准才能执行的，那现在就来看一下 VS2022 是否遵循ANSI C标准。

可以看到 VS2022 是不遵循 ANSI C 标准的，但是 gcc 编译器是遵循 ANSI C 标准的，我们将该代码在 Linux 环境下运行一下。

我想有小伙伴就会说了，好像这个东西也没有什么用啊。其实这个还是有点用的，可以帮我们生成一个日志，方便查看代码什么时间、什么地方出现了问题。

#include <stdio.h>
int main()
{
	int i = 0;
	FILE* pf = fopen("log.txt", "a+");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	for (i = 0; i < 10; i++)
	{
		fprintf(pf, "%s %d %s %s %d\n", __FILE__, __LINE__, __DATE__, __TIME__, i);
	}
	fclose(pf);
	pf = NULL;

	return 0;
}

#define

一、#define 定义标识符

语法：
#define name stuff

#include <stdio.h>
#define M 100

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

#define 是用来定义符号的，但不仅仅只能定义常量，还可以做其他的东西。比如：为关键字创建一个简短的名字等。

#include <stdio.h>
#define reg register
int main()
{
	reg int num = 0;
	printf("%d\n", num);
	return 0;
}

用更形象的符号来替换一种实现，比如创建死循环。

#include <stdio.h>
#define do_forever for(;;)

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

也有可能有些程序员之前是学习其他语言的，现在来学习C语言。之前学习的语言里switch语句的每个case后面是不用加break，那么现在使用C语言的switch语句，就很容易忘掉加上break。那我们也可以通过 #define 来解决这个问题。

#include <stdio.h>
#define CASE break;case

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

	switch (n)
	{
	case 1:
		printf("hehe\n");
	CASE 2 :
		printf("haha\n");
	CASE 3 : 
		printf("heihei\n");
	}
	return 0;
}

上面的代码可等效为下面的代码。

#include <stdio.h>
#define CASE break;case

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

	switch (n)
	{
	case 1:
		printf("hehe\n");
		break;
	case 2 :
		printf("haha\n");
		break;
	case 3 :
		printf("heihei\n");
	}
	return 0;
}

知道了 #define 的几个应用后，那博主现在问大家一个问题：在define定义标识符的时候，要不要在最后加上 ; 呢？

其实大多数情况还是不要在最后加上;，避免出现无谓的错误。如果真的有需求的话，可以在最后加上;。接下来，我们来看一个例子。

错误的例子：

#include <stdio.h>
#define M 1000;

int main()
{
	int a = 10;
	int b = 0;
	if (a > 10)
		b = M;
	else
		b = -M;
	 
	return 0;
}

上面的代码等效于下面的代码。

#include <stdio.h>
#define M 1000;

int main()
{
	int a = 10;
	int b = 0;
	if (a > 10)
		b = 1000;
	;
	else
		b = -1000;
	;
	return 0;
}

if语句后面跟了句空语句，这就会导致else无法和if匹配上，导致语法错误。只要将 #define 定义标识符后面的;去掉，就能解决了这个语法错误了。所以在 #define 定义标识符的时候，很多时候不需要在最后加上 ;。

二、#define 定义宏

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

下面是宏的声明方式：

#define name( parament-list ) stuff

其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。

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

代码示例：

#include <stdio.h>
#define SQUARE(X) X*X
//#define SQUARE (X) X*X  符号 内容

int main()
{
	printf("%d\n", SQUARE(3));
	//printf("%d\n", 3 * 3);
	return 0;
}

如果我们的宏向上面的代码那样写的话，就会存在一个问题。比如：给宏SQUARE传的参数是3 + 1，这时候就得不到我们想要的结果了。原因就是：宏的参数是不经过任何计算，就直接传过去的。

#include <stdio.h>
#define SQUARE(X) X*X
//#define SQUARE (X) X*X  符号 内容

int main()
{
	printf("%d\n", SQUARE(3+1));//7
	//printf("%d\n", 3 + 1 * 3 + 1); //宏的参数是不经过任何计算，就直接传过去的
	return 0;
}

除了上面的例子外，还有很多的例子。比如：

#include <stdio.h>
#define DOUBLE(X) (X)+(X)

int main()
{
	printf("%d\n", 10 * DOUBLE(4));//44
	//printf("%d\n", 10 * (4) + (4));
	return 0;
}

所以，在定义宏的时候，要给宏多加几个括号以达到自己想要的效果。

#include <stdio.h>
#define SQUARE(X) ((X)*(X))
//#define SQUARE (X) X*X  符号 内容

int main()
{
	printf("%d\n", SQUARE(3 + 1));//16
	return 0;
}

#include <stdio.h>
#define DOUBLE(X) ((X)+(X))

int main()
{
	printf("%d\n", 10 * DOUBLE(4));//80
	
	return 0;
}

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

三、#define 替换规则

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

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

注意：

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

举几个例子来说明一下上面的内容。

#include <stdio.h>
#define M 100
#define MAX(X, Y) ((X)>(Y)?(X):(Y))

int main()
{
	int max = MAX(101, M);
	//int max = MAX(101, 100);
	//int max = ((101)>(100)?(101):(100));
	printf("%d\n", max);
	return 0;
}

因为M是 #define 定义的符号，所以它首先被替换成100。然后101和100再将相应的宏和参数名替换掉。最后，往下搜索，看还有没有 #define 定义的符号和宏。

当预处理器搜索 #define 定义的符号的时候，字符串常量的内容并不被搜索。

#include <stdio.h>
#define M 100

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

因为M是在字符串内的，所以它不会被替换成相应的常量。

四、#和##

1.#

#可以将参数插入到字符串

学习这个之前，我们先来看一段代码。

#include <stdio.h>
int main()
{
	printf("hello world\n");
	printf("hello " "world\n");
	return 0;
}

我们可以发现字符串是有自动连接的特点的。知道了这个，我们就来学习#的作用。

#include <stdio.h>
#define PRINT(X) printf("the value of "#X" is %d\n",X);

int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	PRINT(a);
	//printf("the value of ""a"" is %d\n", a);
	PRINT(b);
	//printf("the value of ""b"" is %d\n", b);
	PRINT(c);
	//printf("the value of ""c"" is %d\n", c);
	return 0;
}

#include <stdio.h>
#define PRINT(X, FORMAT) printf("the value of "#X" is "FORMAT"\n",X);

int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	float f = 5.2f;
	PRINT(a, "%d");
	PRINT(b, "%d");
	PRINT(c, "%d");
	PRINT(f, "%f");
	//printf("the value of ""f"" is ""%f""\n", f);
  return 0;
}

我们可以发现，当我们传的参数不一样，打印的字符串也不一样。这就#的作用了，将参数替换成相应的字符串。这用一个单一的函数接口是很难实现的，所以这也是一个非常好用的技巧。当时不要就#漏掉了，否则就会出错。

2.##

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

究竟是什么意思呢？看完下面的代码，你就懂了。

#include <stdio.h>
#define CAT(X, Y) X##Y  //将两个符号合成一个符号

int main()
{
	int class107 = 520;
	printf("%d\n", CAT(class, 107));
	//printf("%d\n", class107);
	return 0;
}

需要注意的是，##可以将多个符号合成一个符号，不只局限于将两个符号合成一个符号。

注意：这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。

五、带副作用的宏参数

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

例如：

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

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

#include <stdio.h>
#define MAX(X, Y) ((X)>(Y)?(X):(Y))

int main()
{
	int a = 5;
	int b = 8;
	int m = MAX(a++, b++);
	//int m = ((a++) > (b++) ? (a++) : (b++)); //宏替换

	printf("%d\n", m);
	printf("a = %d b = %d\n", a, b);
	return 0;
}

如果将MAX宏替换成Max函数，就可以看到宏和函数的一些区别了。

#include <stdio.h>
int Max(int x, int y)
{
	return x > y ? x : y;
}

int main()
{
	int a = 5;
	int b = 8;
	int m = Max(a++, b++);
	printf("%d\n", m);
	printf("a = %d b = %d\n", a, b);
	return 0;
}

六、宏和函数对比

宏通常被应用于执行简单的运算。比如在两个数中找出较大的一个。

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

1.宏的优点

那为什么不用函数来完成这个任务？原因有二：

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

2.宏的缺点

1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序 的长度。

2. 宏是没法调试的。（在预编译期间，就发生了 #define 定义的符号和宏的替换 ）

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*)mallo(10 * sizeof(int));
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
		printf("%d ", p[i]);
	}
	free(p);
	p = NULL;
	return 0;
}

3.宏和函数的对比

七、命名约定

一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者。那我们平时的一个习惯是：

把宏名全部大写，函数名不要全部大写

#undef

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

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

移除宏定义后，该宏定义的标识符就不能再使用了。

命令行定义

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

比如，我在 Linux 系统上写了一份test.c代码。

其中M的大小是没有定义的，所以直接编译这个代买会出错。

但是我们可以输入指令gcc test.c -D M=10，进行命令行定义。那么这个代码就能通过编译并生成可执行程序。

条件编译

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

比如说：调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。

#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__
		printf("%d\n", arr[i]);//为了观察数组是否赋值成功。
#endif 
	}
	return 0;
}

如果我们不需要打印数组元素的值了，我们就可以将__DEBUG__的定义给去除掉。

常见的编译指令

• #if 常量表达式
  //…语句
  #endif //常量表达式由预处理器求值。
  如：
  #define __DEBUG__ 1
#if __DEBUG__ //..语句
#endif
• 多个分支的条件编译
  #if 常量表达式 //…
  #elif 常量表达式 //…
  #else //…
  #endif
  注意：只要前面的表达式有一个满足，后面的表达式就算满足了也不会编译。
• 判断是否被定义
  #if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol
• 嵌套指令
  

代码示例 1

//满足条件就编译
#include <stdio.h>
int main()
{
#if 1==1
	printf("hehe\n");
	//因为前面的表达式满足，所以后面的语句就算满足了也不会编译
#elif 2==2
	printf("haha\n");
#else
	printf("heihei\n");
#endif
#if 0
	printf("hello world\n");
#endif
	return 0;
}

代码示例 2

#include <stdio.h>
#define PRINT 1
int main()
{
	//如果PRINT定义了，就编译后面的语句
#ifdef PRINT
	printf("hello world1\n");
#endif

#if defined(PRINT)
	printf("hello world2\n");
#endif
	return 0;
}

代码示例 3

//如果PRINT没有定义，就编译后面的语句
#include <stdio.h>
int main()
{
#ifndef PRINT
	printf("hello world1\n");
#endif

#if !defined(PRINT)
	printf("hello world2\n");
#endif
	return 0;
}

关于嵌套条件编译的例子就不举了，大家可以发挥自己的聪明才智想一想好的例子。

除了以上所列举的例子，条件编译还有用来注释代码。比如：

//相当于将下面的代码注释掉了
#if 0

#define PRINT 1
int main()
{
#if PRINT
	printf("hello world\n");
#endif
	return 0;
}

#endif

博主在 Linux 环境下对上面的代码进行了预处理操作，并查看test.i文件里的内容，可以发现没有任何的信息，说明这段不会参与后面的编译。

文件包含

我们已经知道， #include 预处理指令可以使另外一个文件被编译。这种替换的方式很简单：
预处理器先删除这条指令，并用包含文件的内容替换。如果一个源文件被包含10次，那就实际被编译10次。

一、头文件被包含的方式

1.本地文件包含

#include "filename"

2.库文件包含

#include <filename.h>

• <> 和 ""包含头文件的本质区别是：查找的策略的区别
• "" 1.代码所在的目录下查找 2.如果第一步找不到，则在库函数的头文件目录中查找
• <> 直接去库函数头文件所在的目录下查找

Linux环境的标准头文件的路径

/usr/include

VS环境的标准头文件的路径

C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
//这是VS2013的默认路径，注意按照自己的安装路径去找。

如果去库函数头文件所在的目录下查找也查找不到所包含的文件的话，就会提示编译错误。

注意：对于库文件也可以使用 "" 的形式来包含，但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。

二、嵌套文件包含

如果出现下图这样的场景：

comm.h和comm.c是公共模块。
test1.h和test1.c使用了公共模块。
test2.h和test2.c使用了公共模块。
test.h和test.c使用了test1模块和test2模块。
这样最终程序中就会出现两份comm.h的内容。这样就造成了文件内容的重复。

再举个例子，在 Linux 环境下编写了两份代码，预处理后可以看到头文件test.h的内容被包含了两次。

那如何解决这个问题呢？我们可以借助条件编译。

每个头文件的开头可以这样写：

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

或者

#pragma once

这样就可以避免头文件的重复包含了。

在头文件test.h开头写上#pragma once，就算源文件test.c内包含了两次头文件test.h，也只会包含一次头文件test.h。

在本篇文章讲解的预处理指令就是这些，其实还有很多其他的预处理指令。比如：#error、#pragma、#line和#pragma pack()等等，大家可以自行搜索学习或者参考《C语言深度剖析》来学习，在这里就不一一讲解了。

👉总结👈

在本篇文章里，主要讲解了翻译环境中的预处理（预编译）、编译和链接、运行环境、预处理详解，也介绍了相关的预处理指令。如果大家觉得文章写得不错，大家给个三连支持一下哦！谢谢大家啦！💖💝❣️