前言

感谢老铁们的陪伴和支持，初始C语言专栏在本章内容也是要结束了，这创作一路下来也是很不容易，如果大家对 Java 后端开发感兴趣，欢迎各位老铁来我的Java专栏！当然了，我也会更新几章C语言实现简单的数据结构！不过由于我是Java 技术栈的，所以如果以后有机会学习C++的话，我会重新回来把C语言进阶专栏更完的！

Java专栏：JavaSE

C语言数据结构专栏：C语言进阶

个人主页：熵减玩家
个人格言：为祖国添砖加瓦（Java)~~

编译与链接

翻译环境和运行环境

       在源文件到程序运行结果的过程中，经过了两种环境，在翻译环境中形成可执行的机器指令（二进制指令），在运行环境中生成可执行的程序（.exe文件）然后输出结果。

翻译环境

       在翻译环境中有两个过程，一个是编译（而编译又可以分解成：预处理（有些书也叫预编译）、编译、汇编三个过程。），另一个是链接。
预编译我会在下面详细介绍~

⼀个C语言的项目中可能有多个 .c 文件⼀起构建，那多个 .c ⽂件如何生成可执行程序呢？
• 多个.c文件单独经过编译器，编译处理生成对应的目标⽂件。
• 注：在Windows环境下的⽬标⽂件的后缀是 .obj ，Linux环境下⽬标⽂件的后缀是 .o
• 多个⽬标文件和链接库⼀起经过链接器处理生成最终的可执行程序。
• 链接库是指运行时库(它是支持程序运行的基本函数集合)或者第三方库。

如果再详细一点的话，回分为下面的步骤：
以gcc为例：

拆分编译三个过程

       这里提到的编译是翻译环境里的大的编译，所以其被拆分成三个过程分别是：预处理，编译，汇编。

预处理（预编译）

       这里作简单的介绍，下面又更加详细的预处理详解~~

预处理阶段主要处理那些源⽂件中#开始的预编译指令。比如：#include,#define，处理的规则如下：
• 将所有的 #define 删除，并展开所有的宏定义。
• 处理所有的条件编译指令，如： #if、#ifdef、#elif、#else、#endif 。
• 处理#include 预编译指令，将包含的头⽂件的内容插⼊到该预编译指令的位置。这个过程是递归进行的，也就是说被包含的头文件也可能包含其他⽂件。
• 删除所有的注释
• 添加行号和文件名标识，方便后续编译器生成成调试信息等。
• 或保留所有的#pragma的编译器指令，编译器后续会使⽤。
经过预处理后的.i文件中不再包含宏定义，因为宏已经被展开。并且包含的头文件都被插入到.i⽂件中。所以当我们⽆法知道宏定义或者头文件是否包含正确的时候，可以查看预处理后的.i文件来确认。

编译

这里的编译又被分成三个小过程，词法分析、语法分析、语义分析及优化

词法分析

将源代码程序被输⼊扫描器，扫描器的任务就是简单的进行词法分析，把代码中的字符分割成⼀系列的记号（关键字、标识符、字⾯量、特殊字符等）

array[index]=(index+4)*(2+6)

上⾯程序进行词法分析后得到了16个记号：

语法分析

接下来语法分析器，将对扫描产⽣的记号进⾏语法分析，从⽽产⽣语法树。这些语法树是以表达式为节点的树。

语义分析

由语义分析器来完成语义分析，即对表达式的语法层⾯分析。编译器所能做的分析是语义的静态分析。静态语义分析通常包括声明和类型的匹配，类型的转换等。这个阶段会报告错误的语法信息。

汇编

汇编器是将汇编代码转变成机器可执行的指令，每⼀个汇编语句几乎都对应⼀条机器指令。就是根据汇编指令和机器指令的对照表⼀⼀的进行翻译，也不做指令优化。

链接

链接是⼀个复杂的过程，链接的时候需要把⼀堆文件链接在⼀起才生成可执行程序。
链接过程主要包括：地址和空间分配，符号决议和重定位等这些步骤。
链接解决的是⼀个项⽬中多文件、多模块之间互相调用的问题。

例如：在一个工程中，链接就是把这个工程中所有的头文件，源文件全部连接在一起，形成一个可执行的程序。

我们已经知道，每个源文件都是单独经过编译器处理生成对应的目标文件。
test.c 经过编译器处理生成 test.o
add.c 经过编译器处理生成 add.o
我们在 test.c 的⽂件中使用了 add.c 文件中的 Add 函数和 g_val 变量。
我们在 test.c ⽂件中每⼀次使用 Add 函数和 g_val 的时候必须确切的知道 Add 和 g_val 的地址，但是由于每个文件是单独编译的，在编译器编译 test.c 的时候并不知道 Add 函数和 g_val变量的地址，所以暂时把调用 Add 的指令的。目标地址和 g_val 的地址搁置。等待最后链接的时候由链接器根据引⽤的符号 Add 在其他模块中查找 Add 函数的地址，然后将 test.c 中所有引⽤到Add 的指令重新修正，让他们的目标地址为真正的 Add 函数的地址，对于全局变量 g_val 也是类似的方法来修正地址。这个地址修正的过程也被叫做：重定位。

所以当出现函数未定义的报错信息时，就是在连接的时候出错的！！！

如果大家还想更加深入了解上面的过程，可以去阅读《程序员的自我修养》这本书！

运行环境

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

预处理详解

       这里我们就来详细解剖预处理~~

预定义符号

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

__FILE__ //进⾏编译的源⽂件
__LINE__ //⽂件当前的⾏号
__DATE__ //⽂件被编译的⽇期
__TIME__ //⽂件被编译的时间
__STDC__ //如果编译器遵循ANSI C，其值为1，否则未定义

我们来使用一下：

#define 定义常量

#define 定义常量，需要在后面写个标识符，后面再跟一个常量即可。

#define M 100

#define 定义宏

宏也可以类比成函数，在#define 后面跟一个标识符，在标识符后面紧跟（参数），一定要进更，否则会被编译器认为这时一个#define 定义常量！！！

#define SUM(x,y) x+y

要注意了，宏是不允许出现递归的！！！

续航符 \

当#define 定义的宏或者参数很长时，为了更好的阅读，我们会把它拆分成好几行，为了不发生编译错误，我们需要加上续航符 \

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

#define替换的规则

所有的#define 定义的常数或者宏都会被替换成你定义的值或式子。
注意，只会替换，不会参与任何计算！！！

带有副作用的宏参数

       由于我们知道#define 只会完成替换，并不会参与计算，所以你传进去的值可能不是你的预期结果。
举个栗子：

#define SQUARE(x) x*x

当你传入1+3(即SQUARE(1+3))，程序替换后会变成这样：1+3*1+3 ；算出来的结果就是7，而不是16，所以宏在使用的时候会用一定的副作用。

如何避免：

加多点括号，不要吝啬你的括号！！！

修改之后的宏定义：

#define SQUARE(x) ((x) * (x))

这样定义之后，你传进去的1+3 替换后就变成了：（（1+3）*（1+3））

宏与函数的对比

1.宏的代码量更少，在完成一些小型计算的时候，会比函数更快，因为函数需要调用函数，进行计算，然后返回结果，相比之下，宏会有优势一些。
举个例子：比较两个值的大小
函数：

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

宏：

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

2.宏不会进行参数类型检查，而函数会，就也体现了宏对参数类型是不会限制的，只要传值就可以了，在上面的例子就体现到这一点，上面的例子中max函数需要传入两个整型的值，而宏却不用。
由于宏对参数类型没有检查，我们在malloc 开辟空间的时候其实也可以用宏来写：

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

由于宏没有参数类型检查，所以不够严谨，即有优点，也有缺点。

3.由于宏是直接完成替换，所以如果宏出错了，我们不能通过调试来检查出宏的错误，但是函数可以。

4.宏可能会带来运算符优先级的问题，导致程容易出现错。这就是我们上面提到宏参数代有的副作用。

5.宏是不能完成递归的，宏只会完成替换，并不会进行递归，但是函数可以递归！！！

#和##

引入一个东西：

字符串打印的时候，如果中间出现相互配对的" " ;程序会自动合并他们，删除中间的一切空格，有了这个知识之后，我们往下看：

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

就是你不想让这个参数被替换成值，而是想要让它就是原本的字符，可以这样使用 #

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

替换之后：printf(“the value of “a” is “”%d”"",10)
消掉中间的" " ; 变成printf(“the value of a is %d”,10)

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

举个例子，如果你想使用宏来创建int_max,float_max,double_max时，我们需要在_max前面的标签修改一下，为了不被认为是一个与_max组成的一个字符，我们可以使用 ## 来标记：

#include <stdio.h>#define type_max(type) \type type##_max(type x,type y) \{   \return ((x)>(y)?(x):(y));  \}type_max(int);
type_max(double);int main()
{int ret = int_max(3, 5);double ret2 = double_max(5.1, 6.5);printf("%d\n", ret);printf("%lf\n", ret2);return 0;
}

命名约定

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

把宏名全部大写
函数名不要全部大写
不建议#define 定义的常量或者宏后面加上分号; 替换也会把分号替换过去的，所以会很容易出错！

#undef

这条指令⽤于移除⼀个宏定义，使用的时候记得跟你要移除的宏名。

#include <stdio.h>#define M 10int main()
{printf("%d\n", M);
#undef Mprintf("%d\n", M);return 0;
}

命令行定义

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

条件编译

1

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

这个只有当if 后面的表达式为真，后面的代码才会被编译，并且需要使用#endif 来确定你要控制的代码段。

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

2. 多个分支的条件编译

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

这个和if 、else if、else 是类似的，只会进去一个。

3.判断是否被定义

#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol

4.嵌套指令

#if defined(OS_UNIX)#ifdef OPTION1unix_version_option1();#endif#ifdef OPTION2unix_version_option2();#endif#elif defined(OS_MSDOS)#ifdef OPTION2msdos_version_option2();#endif
#endif

他们会自动匹配好，不需要使用大括号！！！

头文件的包含

在一个大型的工程中，每个人负责相应的部分，最后所有人编写的头文件和源文件会链接到一起，所以难免会出现头文件被多次包含的情况，如果不做处理，有多少头文件就会被编译多少，这样会影响到程序的运行效率！
所以我们会使用下面的条件编译指令来避免头文件被多次包含：
例如：

#ifndef __ADD_H__（这里的__是由两个_ 组成的！！！下面也是）
#define __ADD_H__
//头⽂件的内容
#endif //__ADD_H__

当然了，还有一个更加简介的条件编译指令，专门用在头文上，写在头文件的第一行！

#program once

其他预处理指令

除了上面提到的条件编译指令外，还有其他的一些条件编译指令：

#error
#pragma
#line
...
#pragram pack() 在结构体详解中提到过！

这里不做详细解说，大家有兴趣的可以自己学习！！！

《初始C语言》专栏到此完结撒花！！！