程序环境和预处理
前言引入：
在计算机编程的世界中，了解程序的翻译环境和执行环境以及编译链接的过程是非常重要的。这些知识将帮助我们更好地理解代码是如何被翻译成机器语言并最终在计算机上执行的。但是，仅仅了解理论并不足够，我们还需要了解这些知识如何应用于实际的编程项目中。
在编译链接的过程中，了解各个阶段的作用和相互关系也非常重要。这将帮助我们更好地识别和解决编译错误和链接错误，提高代码的质量和可靠性。此外，对编译链接的了解还有助于优化代码，提高程序的执行效率。
在实际的编程项目中，我们经常会遇到需要使用预处理指令来处理代码的情况。例如，在大型项目中，我们可能会使用条件编译来根据不同的平台或配置选择性地编译不同的代码块。这对于确保代码在不同环境下的兼容性和灵活性非常重要。
另外，预处理指令中的文件包含功能也是实际项目中经常使用的工具。通过将代码分成多个文件并使用文件包含，我们可以更好地组织和管理代码，提高代码的可读性和可维护性。此外，文件包含还可以促进代码的重用，减少重复编写代码的工作量。
了解程序的翻译环境和执行环境，以及编译链接的过程是每个程序员都应该具备的基本知识。通过运用这些知识，我们可以更好地应对实际编程项目中的挑战，并编写出高效、可靠且易于维护的代码。同时，预处理指令和文件包含等实际应用也能够提高代码的灵活性和可重用性。所以，让我们深入学习这些知识，将它们应用到我们的实际项目中，为我们的编程之路增添更多的成就感和乐趣。
个人主页：Oldinjuly的个人主页
文章收录专栏：C语言
欢迎各位点赞收藏⭐关注❤️
目录
1.程序的翻译环境和执行环境
2.编译链接详解
2.1 翻译环境
2.2 编译过程划分
2.3 执行环境
3.预处理详解
3.1 预定义符号
3.2 #define
3.2.1 #define 定义标识符
3.2.2 #define 定义宏
3.2.3 #define的替换规则
3.2.4 #和##
3.2.5 带副作用的宏参数
3.2.6 宏和函数的对比
3.2.7 命名约定
3.3 #undef
3.4 命令行定义
3.5 条件编译
3.6 文件包含
3.6.1 头文件被包含的方式
3.6.2 嵌套文件包含
1.程序的翻译环境和执行环境
C语言存在两个不同的环境
翻译环境：源代码转化成可执行的机器指令
执行环境：实际执行代码
2.编译链接详解
2.1 翻译环境
首先我们来看一张图：
- 我们写了多个源文件（比如test1.c,test2.c,test3.c），当程序进行翻译时，首先要经过编译器的编译，最终形成.obj的目标文件（windows环境下是.obj文件,Linux环境下是.o文件），注意：每个源文件都是单独经过编译器编译的。
- 多个.obj文件经过编译后，会和库函数的静态库通过链接器链接在一起，最终形成.exe可执行文件。
- 库函数都是编译好的保存在静态库（.lib文件）中的（里面有库函数的实现），链接多个目标文件就和静态库进行链接。
而我们经常使用的vs2019或者2022是一个集成开发环境，所谓集成，就是集成了编译器、链接器和调试器的工具。
2.2 编译过程划分
其实编译过程是可以细化成三个阶段：预处理（预编译）--> 编译 --> 汇编
在此之前，我么先介绍一下Linux环境下gcc编译器常用的一些命令（注意一下情况只针对Linux）
常规的gcc编译命令：gcc hello.c -o hello | gcc hello.c
命令1：gcc -E hello.c -o hello.i
命令2：gcc -S hello.i -o hello.s
命令3：gcc -c hello.s -o hello.o
命令4：gcc hello.o -o hello
解释：
- 常规命令：-o选项用来指定生成的目标文件，gcc hello.c -o hello，表示生成的目标文件名为hello，这里的hello就是可执行程序；gcc hello.c表示默认生成a.out的可执行成程序；
- 命令1：-E选项表示让gcc在预处理之后停止编译；预处理过后是.i文件；
- 命令2：-S选项表示让gcc在编译之后停止，不进行汇编；编译过后是.s文件；
- 命令3: -c选项表示让gcc在汇编之后停止，不进行链接；汇编之后是.o文件，也就是Linux环境下的目标文件（windows环境下为.obj文件）；
- 命令4：进行链接；链接过后就是可执行文件；
- 总结记忆：ESc，iso
翻译环境细分为四个阶段：预处理-->编译-->汇编-->链接
预处理阶段：完成所有的文本操作
- 注释的删除
- #include 头文件的包含
- #define 符号的替换
- 条件编译#if等的操作
这些所有的预处理指令都是在预处理阶段处理的。关于预处理指令，后面详细介绍。
编译阶段：把所有的C语言代码翻译成汇编指令。
具体包括：
语法分析，词法分析，语义分析，符号汇总
这里只是简单介绍，详细介绍参考《编译原理》
汇编阶段：把汇编代码翻译成二进制的指令，形成符号表
汇编后生成的目标文件（.o文件）里面存放的都是二进制的指令，我们查看不了。
生成的符号表和后面的链接阶段相关。
链接阶段：合并段表，符号表的合并和重定位
需要注意的是：Linux下gcc编译产生的目标文件test.o，可执行文件test都是按照elf这种格式来存储的。
elf这种格式存储的时候，会把文件（目标文件和可执行文件）划分成多个段的形式。链接阶段就是把多个目标文件（.o文件）所对应的符号段表合并在一起。
编译环节，我们就已经进行了符号的汇总；汇编阶段，我们进行了符号表的建立；链接阶段，则进行这些目标文件的符号表的合并、重定位（重定位即是对无效地址的重定位）
关于编译链接符号及符号表的问题，流程如图所示:
上述编译链接的具体过程，在《程序员的自我修养》一书中有详细介绍。
2.3 执行环境
程序执行的过程：
- 程序必须载入内存中。在有操作系统的环境中：一般这个由操作系统完成。在独立的环境中，程序
的载入必须由手工安排，也可能是通过可执行代码置入只读内存来完成。 - 程序的执行便开始。接着便调用main函数。
- 开始执行程序代码。这个时候程序将使用一个运行时堆栈（stack），存储函数的局部变量和返回地址。程序同时也可以使用静态（static）内存，存储于静态内存中的变量在程序的整个执行过程一直保留他们的值。
- 终止程序。正常终止main函数；也有可能是意外终止。
3.预处理详解
上面介绍：程序的翻译过程可以分为：预处理-->编译-->汇编-->链接
下面来详解和预处理相关的语法：预处理指令
3.1 预定义符号
预定义符号是C语言中内置的。具体有如下这些：
__FILE__//进行编译的源文件
__LINE__//文件当前行号
__DATE__//文件被编译的日期
__TIME__//文件被编译的时间
__STDC__//如果文件遵循ANSIC，其值为1，否则未定义
3.2 #define
3.2.1 #define 定义标识符
语法：#define name stuff
所谓定义标识符，这里的stuff可以是常量（数字常量，字符串常量），甚至是关键字和一段代码。
比如：
#define MAX 10
#define STR "abc"
#define INT int
#define FOR for(;;)
#define CASE break;case
#define PRINT_HELLO printf("hello")
注意：#define在定义标识符的时候，建议不要加上;
因为#define是无脑替换，这样会导致多了一条空语句容易出现语法错误。
3.2.2 #define 定义宏
#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏（macro）或定义
宏（define macro）。也就是说 #define定义的宏是允许有参数的。
语法：#define name( parament-list ) stuff
其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。
注意：
参数列表的左括号必须与name紧邻。
如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。
比如：
#define ADD(x,y) x+y
#include
#define ADD(x,y) x+y
int main()
{
int ret = ADD(1, 2);
printf("%d\n", ret);//ret==3
return 0;
}
宏的替换有两步：参数传递-->宏替换
但是宏只是无脑替换，这样就会出现一个问题：
//代码一
#define SQUARE(x) x*x
int ret = SQUARE(a+1);//??这种代码会有什么问题？
我们进行替换过后：a+1*a+1
我们发现，宏替换过后可能会因为运算符优先级的问题而产生一些不可预知的后果。
所以我们要加上括号：
//改进一：
#define SQUARE(x) （x）*（x）
int ret = SQUARE(a+1);
//代码二
#define DOUBLE(x) (x)+(x)
int ret = 10 * DOUBLE(2);//这种代码会有什么问题？
替换过后：10*(2)+(2)
我们发现又是因为运算符优先级的问题发生错误。
所以还要在最外层加上括号：
//改进二：
#define SQUARE(x) (（x）*（x）)
int ret = SQUARE(a+1);
3.2.3 #define的替换规则
在程序中扩展#define定义符号和宏时，需要涉及几个步骤。
- 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。
- 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。
- 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。
注意：
- 宏参数和#define定义中可以出现其他 #define定义的符号。
- 对于宏，不能出现递归。
- 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。
3.2.4 #和##
问题：如何把宏参数插入到字符串中？
补充：字符串有自动连接功能。
int main()
{
printf("hello ""world\n");//输出hello world
return 0;
}
使用 # ：把一个宏参数变成对应的字符串。
比如：#a --> “a”
问题：我们能不能实现一个Print函数，可以用来打印任何类型的数据？
显然这是不可行的，比如不同数据类型的打印格式不同，变量名也不同，所以这是函数无法实现的事情，这时候就可以用宏+#了。
#define PRINT(FORMAT, VALUE) printf("the value of " #VALUE " is " FORMAT "\n", VALUE)
int main()
{
int num = 1;
PRINT("%d", num);//the value of num is 1
return 0;
}
##的作用：
##可以把位于它两边的符号合成一个符号。
它允许宏定义从分离的文本片段创建标识符。
#define ADD_TO_SUM(num, value) sum##num += value;
int main()
{
int sum5 = 1;
ADD_TO_SUM(5, 10);//作用是：给sum5增加10
return 0;
}
3.2.5 带副作用的宏参数
当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能出现危险，导致不可预测的后果。副作用就是表达式求值的时候出现的永久性效果。
x+1;//不带副作用
x++;//带有副作用
#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
x = 5;
y = 8;
z = MAX(x++, y++);
printf("x=%d y=%d z=%d\n", x, y, z);//x=6 y=10 z=9
3.2.6 宏和函数的对比
通过上面对宏的介绍，我们发现这只是一个容易出错，有副作用，可读性还不强的语法，而且他能做的函数也可能会做到，那为什么要设计这种语法呢？
宏通常被应用于执行简单的运算
比如#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
那为什么不用函数来完成这个任务？
原因有三：
- 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。
所以宏比函数在程序的规模和速度方面更胜一筹。- 更为重要的是函数的参数必须声明为特定的类型。
所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以
用于>来比较的类型。
宏是类型无关的。- 宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。
比如：#define MALLOC(num,type) (type*）malloc(num * sizeof(type))
但是很明显宏也是有缺点：
- 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。
- 宏是没法调试的。
- 宏由于类型无关，也就不够严谨。
- 宏可能会带来运算符优先级的问题，导致程容易出现错。
宏和函数的对比：
3.2.7 命名约定
那我们平时的一个习惯是：把宏名全部大写，函数名不要全部大写。
3.3 #undef
这条指令用于移除一个宏定义。
#undef NAME
//如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除。
3.4 命令行定义
许多C 的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。
比如Linux下的gcc编译器：
命令行编译指令：
gcc test.c -D ARRAY_SIZE=100 -o test
#include
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;
}
3.5 条件编译
在编译一个程序的时候我们如果要将一条语句（一组语句）放弃编译是很方便的。因为我们有条件编译指令。
常见的条件编译指令：
表达式为真，里面的代码参与编译；表达式为假，预处理时直接删除代码，不参与编译。（这里和if语句的差别还是很大的）
#if 常量表达式
//...
#endif
//常量表达式由预处理器求值。
如：
#define __DEBUG__ 1
#if __DEBUG__
//..
#endif
//2.多个分支的条件编译
#if 常量表达式
//...
#elif 常量表达式
//...
#else
//...
#endif
//3.判断是否被定义
#if defined(symbol)//这里不管真假，只关注是否被定义
//...
#endif
#ifdef symbol
//...
#endif
#if !defined(symbol)
//...
#endif
#ifndef symbol
//...
#endif
//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
3.6 文件包含
#include 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方一样。
这种替换的方式很简单：预处理器先删除这条指令，并用包含文件的内容替换。
这样一个源文件被包含10次，那就实际被编译10次。
3.6.1 头文件被包含的方式
库文件包含
#include
查找策略：在标准库路径下查找。找不到报错。
本地文件包含
#include "add.h"
查找策略：先在源文件所在的当前工作目录下查找，如果没找到，编译器就会像查找库文件一样在标准库路径下查找。
所以库文件是可以用“ ”包含的，但是不建议。这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。
3.6.2 嵌套文件包含
comm.h和comm.c是公共模块。
test1.h和test1.c使用了公共模块。
test2.h和test2.c使用了公共模块。
test.h和test.c使用了test1模块和test2模块。
这样最终程序中就会出现两份comm.h的内容。这样就造成了文件内容的重复。
这种嵌套包含会出现头文件重复包含的问题
头文件重复包含可能会导致一些问题，包括以下几个方面：
- 编译错误：如果同一个头文件被多次包含，编译器可能会发生重复定义的错误。这是因为头文件中通常包含了函数、变量等的声明，重复包含会导致这些声明被重复定义，从而引发编译错误。
- 多重定义：如果同一个头文件被多次包含，其中包含了函数、变量的定义，而不是仅仅是声明，那么会导致这些函数、变量被多重定义。这将引发链接错误，因为链接器无法确定应该使用哪个定义。
- 编译时间延长：重复包含会增加编译时间，因为每次包含都会重新处理头文件中的内容。尤其是对于大型项目和频繁重复包含的情况，会导致编译时间大幅增加。
如何解决？条件编译！
每个头文件开头这样写
#ifndef __TEST_H__//根据头文件的名字来1起
#define __TEST_H__
int Add(int x,int y);//头文件的内容
#endif
或者
#pragma once//现代写法
int Add(int x,int y);//头文件的内容
补充：头文件中改写什么？
- 自定义类型的声明
- 函数的声明
- 其他头文件的包含
头文件中不能写变量的定义以及函数的定义，否则出现重定义的链接错误。
笔试题：《高质量C/C++编程》
- 头文件中的 ifndef/define/endif是干什么用的?
防止头文件重复包含
- #include
和 #include "filename.h"有什么区别? 查找策略的不同