⭐博客主页：️CS semi主页
⭐欢迎关注：点赞收藏+留言
⭐系列专栏：C语言进阶
⭐代码仓库：C Advanced
家人们更新不易，你们的点赞和关注对我而言十分重要，友友们麻烦多多点赞＋关注，你们的支持是我创作最大的动力，欢迎友友们私信提问，家人们不要忘记点赞收藏＋关注哦！！！

---

前言

不知道大家有没有想到一个问题，当我们在VS编译器里要想呼出输出窗口，只需要ctrl+F5即可，立马就跳出控制台，就像我们利用ctrl+F5按键能够将一个test.c的程序变成test.exe程序，这些是怎么做的呢？？那当然了，是需要细致的了解的。本章节难度较大，把稳方向盘，极速出发。

---

一、程序的翻译环境和执行环境

我们简单来了解一下翻译环境和执行环境：

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

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

解释：

大家看图，我们需要将test.c转换成为test.exe（可执行程序）是需要IDE的，也就是我们的VS2022集成开发环境，摁一个ctrl+f5即可，而我们如果想得到运行结果的话就需要我们有执行环境。在翻译环境下会进行编译和链接；在汇编阶段会将汇编指令转换成二进制指令，如下：

二、详解编译+链接

（一）翻译环境

1.简单介绍

根据这张图片我们可以清晰的知道，我们的源文件要想转化成可执行程序的话，是一个大的翻译环境，这个大的翻译环境包含了两个关键的要素，第一个是编译（依赖编译器），第二个是链接（依赖连接器）。

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

2.编译

这里是需要用到Linux的知识，所以我们这里只讲结论，不做演示（因为我自己不会用Linux哈哈）。
这个是我们需要用到的Linux的指令，有Linux大佬可以忽略：

1. 预处理 选项 gcc -E test.c -o test.i
   预处理完成之后就停下来，预处理之后产生的结果都放在test.i文件中。
2. 编译 选项 gcc -S test.c
   编译完成之后就停下来，结果保存在test.s中。
3. 汇编 gcc -c test.c
   汇编完成之后就停下来，结果保存在test.o中。

如下图，是在编译里面进行的三个操作的详细内容：

经过这些的操作和概念，我们其实要引入一个新的概念，就是符号表的概念。

3.符号

注意：我们下面用到的代码是：

//test.c
//声明外部符号
extern int Add(int x, int y);

int main() {
	int a = 10;
	int b = 20;
	int ret = Add(a, b);
	
	return 0;
}

//add.c
int Add(int x, int y) {
	return x + y;
}

Linux里面的test.o - 这个文件是elf格式
我们用readelf这个工具打开可以看到各类的符号。

ps:0x0000是无效地址。

4.链接

1.合并段表：将一个个段进行连接合并：
2.符号表的合并和重定位：其实很好理解，根据作用的名称即可，由前面的例子来讲，Add这个符号是出现了两次，且两个是相互独立的空间，所以链接就是把它们合并和连接进行重定位，变成一个表内，这样子通过地址就能去访问了。重定位是在符号表合并后，程序只认识新的合成后的符号表，并将符号表作为运行的信息。

5.总结

我们这里讲解的是翻译环境的效用，翻译环境分为两大板块，一个是编译，另一个是链接。关于编译，我们分为三个模块，分别为预处理、编译和汇编，各个功能有不同的作用和概念，而到了链接环节，则是有两大功能，合并段表和合并符号表和重定位，这里我们引进了符号表的概念，是将这些符号进行分流，有符号和地址，符号表的作用很强大，能够将多个源文件（.c文件）进行链接，通过符号表就可以找到其他可以链接的函数，再链接的功能将它们连接起来，从而实现链接的作用，编译和链接的功效合起来就能变成可执行文件（.exe）。

（二）运行环境

程序执行的过程：

1. 程序必须载入内存中。在有操作系统的环境中：一般这个由操作系统完成。在独立的环境中，程序的载入必须由手工安排，也可能是通过可执行代码置入只读内存来完成。
2. 程序的执行便开始。接着便调用main函数。
3. 开始执行程序代码。这个时候程序将使用一个运行时堆栈（stack），存储函数的局部变量和返回地址。程序同时也可以使用静态（static）内存，存储于静态内存中的变量在程序的整个执行过程一直保留他们的值。
4. 终止程序。正常终止main函数；也有可能是意外终止。

三、预处理详解

（一）预定义符号

我们试一试（这些预定义符号都是语言内置的）：

（二）#define

1.介绍

语法：
#define name stuff

我们有以下几种情况，因为我们之前讲过，这个#define在编译期间的预处理时，就已经消失不见了，这个#define里面的替换内容直接在函数内部进行替换了：

那我们可以根据上面的操作进行编译并讲解一下：
No.1：
No.2:
No.3:
No.4:

2.小提问

在define定义标识符的时候，要不要在最后加上 ; ?

答案：可以是可以，但有时候会出问题，因为我们进行替换的时候是将;连同前面的数值一起被替换的，所以会有一定的歧义，就比如下面这个代码，是会出现问题的：

因为这个M为1000;，所以是进行预处理替换的时候会是替换过去1000;的。

3.#define 定义宏

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

宏的申明方式：
#define name( parament-list ) stuff
其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。

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

如下代码所示：

既然这样是可以的，很完美的，可是大家想过一个问题吗？当我们这个printf内部的宏定义最后变成了SQUARE（2+1）以后了呢，里面装了加法还能是以前的结果吗？那我们直接进行打印一下：

是5而不是7！？这似乎有点奇怪啊，但是我们的宏呢，是先进行替换的，再进行计算的，是直接将里面的参数进行替换的，那就相当于printf(“%d\n”,2+1*2+1)中间是没有括号的。是不是很神奇，因为我们讲过了，编译是先进行预处理再进行执行的时候进行计算，那就是先直接进行替换即可。

如果我们不是这样想要的结果，那我们加个括号不就好了吗！？

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

同样的，来一道题目来练个手吧！！！

答案是8，大家做对了吗？
其实就是相当于(2+1+1)*2+1/2=8。

4.#define 替换规则

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

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

注意：

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

5.#和##

如何把参数插入到字符串中？

（1）引例

大家看一下下面这串代码，输出的是什么？

答案当然是输出的都是hello world。所以我们发现字符串是有自动连接的特点的。那我们就想来一个操作了，当我们在写一个变量等于不同值的情况下，这个变量始终无法写出来，就像下面这个代码：

我们想输出注释的这几行显示的话该怎么办呢？我们发现这个a,b,c始终无法进行替换，因为在printf中是一个常量字符串形式，是无法进行更改的，所以我们有了接下来的操作了，是利用了#和字符串自动粘连的特点的。

（2）#的作用

如图显示，当我们加了这个#的时候就能实现这种作用了，因为#X会变成“a”、“b”、“c”。

所以我们得到的结论是：使用 # ，把一个宏参数变成对应的字符串。

那我们再改进改进，我们现在想的是传参是float,double……型的数据怎么办呢？那其实也不难，我们只需要传不一样的参数不就好了吗，那我们进行改造改造：

这样子就能达到我们的要求了。替换过程：

（4）## 的作用

##可以把位于它两边的符号合成一个符号。
它允许宏定义从分离的文本片段创建标识符。
大家看下面的神奇的代码，是不是很神奇，它能够将符号连接起来使用哦~~这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。

6.带副作用的宏参数

我们之前学过关于前置++和后置++是有副作用的，是将本身的数进行自加或者自减。
所以，当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能出现危险，导致不可预测的后果。副作用就是表达式求值的时候出现的永久性效果。
大家直接看代码：

答案是9，其实大家都能想到这个答案，但我们往深处探索一下，这个a和b的值是多少呢？那我们就需要进行解析了，如下解析：

我们进行比较的是5和8，而比较完后a和b都自增1，而我们到后面是计算的是b++，所以b再进行自增1，得到10，而a是6。如下结果：

7.宏和函数对比

宏比函数的优点：

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹。（我们在函数进行调用之前有很多的工作，这是函数栈帧的创建，比如利用寄存器进行开辟空间，利用寄存器进行寻找等操作，花费的时间很长。）
2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以用于>来比较的类型。（无论是什么类型的值，只要是参数传过去我们就可以进行比较了）
   宏是类型无关的。

宏的劣势：

1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。（当我们定义的宏过于长的时候，再进行预编译的时候会将代码里面有宏的地方全部替换成宏，而宏过于长的话那就替换的过于长，代码过于长了）
2. 宏是没法调试的。（我们进入调试界面压根没有此调试）
3. 宏由于类型无关，也就不够严谨。（如果我们的要求是全部是int类型的，那我们此时不小心传错类型过去，这个宏以为没问题，机器不报错，那就不够严谨了）
4. 宏可能会带来运算符优先级的问题，导致程容易出现错。（因为宏替换仅仅是替换，当我们要进行运算的时候是需要进行加括号的，是很复杂的）

宏和函数的一个对比：

8.命名约定

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

（三）#undef

这条指令用于移除一个宏定义。
用法如下：

（四）命令行定义

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

什么意思呢？理解起来其实不难，就是当我们单纯定义一个数组，这个数组的大小我们定义的一个未定义的值，但是我们通过命令行参数进行赋值，这个代码还是可以跑起来的。这是在程序预编译的时候改变一些参数，使他们能够随时随地发生变化，如下代码:

乍一看这个ARRAY_SIZE是一个完全未定义的参数，命令行定义在VS中没办法进行演示，但在Linux中可以用命令行进行演示（gcc -D ARRAY_SIZE=10 programe.c），大家有虚拟机可以试一试这个感受感受。

（五）条件编译

1.介绍

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件编译指令。即：满足条件就编译，不满足条件就不编译。
怎么用呢？我们可以简单的把这个条件编译看做一个开关，当我们条件满足就编译，条件不满足就不编译，那我们简单写一个代码来解析一下吧：
我们利用#ifdef和#endif的操作将这段代码不进行编译，因为在预处理的时候就将这一大串都删除了，这是非常有意思的，当我们在上面进行宏定义以后就能编译。

2.常见的条件编译指令

（1）一个常量表达式

有两种：
1.#if 常量表达式（非0为真，0为假）
//…
#endif

2.#define _DEBUG_ 1
#if _DEBUG_
//…
#endif

（2）多个分支的条件编译

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

（3）判断是否被定义

#ifdef


#ifndef


#if defined(symbol)


#if !defined(symbol)

（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.介绍

#include 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方一样。
替换方式：
预处理器先删除这条指令，并用包含文件的内容替换。
这样一个源文件被包含10次，那就实际被编译10次。

2.头文件被包含的方式

（1）本地文件包含和库文件包含演示

<>和""包含头文件的本质区别是：查找的策略的区别

（2）本地文件包含路径

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

（3）库文件包含路径

查找策略：查找头文件直接去库函数标准路径下去查找，如果找不到就提示编译错误。
如下图进行查找路径（用EOF转到定义再打开文件夹位置）:我的vs2022文件包含路径为：D:\WindowsKits\10\Include\10.0.22000.0\ucrt
大家可以看看自己的是什么。

（4）小问题

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

3.嵌套文件包含

comm.h和comm.c是公共模块。
test1.h和test1.c使用了公共模块。
test2.h和test2.c使用了公共模块。
这样，test.h和test.c使用了test1模块和test2模块。
这样最终程序中就会出现两份comm.h的内容。这样就造成了文件内容的重复。
造成的问题：
引了多次同样的头文件，会造成代码的冗余，因为在编译的情况下会导致代码相同段太多了，空间开销太大了。

解决方法：
方法一：大家记得我们在刚开辟一个头文件的时候会出现一个#pragma once吗？
当我们加上这个就会只有一次头文件的包含，防止了一个头文件被重复多次的包含。
方法二：
#ifndef _TEST_H//（杠杠TEST杠H杠杠）
#define _TEST_H
//头文件的内容
#endif
解释一下，当第一次进去的时候，没有定义TEST，那就定义一下，然后底下操作，第二次进去，我们早已定义过了，为假下面就不操作。

如下图，头文件做法：

---

总结

程序环境是分为翻译环境和运行环境，这两者进行递推的操作使得整个程序完成，是十分重要的，这些的环境都是较为难的，是要用Linux进行演示的，同样，我们进行预处理的时候是很奇妙的，是我们之前从未涉及过的，所以，要想搞懂这些，肯定需要花大把大把的时间的。

---

客官，来个三连支持一下吧~~