第二十一讲：编译和链接

1.翻译环境和运行环境

在ANSI C（标准C）的任何一种实现中，都存在着两种不同的环境：
1.翻译环境：将一个"test.c"文件变成"test.exe"文件的过程，也就是将源代码变成可执行程序的过程
2.运行环境：就是执行可执行程序的过程，用于实际执行代码

画图来理解：

1.1翻译环境

翻译环境分为编译和链接两大部分，而编译又由预处理（预编译）、编译、汇编三部分组成，所以翻译环境通过画图来分析可以看成：

所以 程序编译和链接总的情况为：

注意：
1.每个.c文件都会单独经过编译器生成对应的目标文件
2.在Windows环境下，目标文件的后缀为.obj，Linux环境下目标文件的后缀为.o
3.多个目标文件和链接库一起经过链接器生成可执行程序
4.链接库是指运行时库或第三方库

详细的过程如下：

1.2编译

1.2.1预编译（预处理）

如果想在gcc环境下观察test.c处理之后的.i文件，命令如下：

gcc -E test.c -o test.i

预编译规则：
1.将所有的#define删除，并展开所有的宏定义，也就是说在.i文件中看不到#define了
2.处理所有的条件编译指令，如#if、#ifdef、#elif等，它允许程序员根据编译时的条件来决定是否编译代码的特定部分，以#开头，在正式编译之前
3.处理#include指令，将包含的头文件的内容插入到该预编译指令的位置，这个过程是递归进行的，因为这个头文件中也可以包含其他的头文件，也就是说，.i文件中有着include包含的头文件内容
4.删除所有的注释
5.添加⾏号和⽂件名标识，⽅便后续编译器⽣成调试信息等。
6.或保留所有的#pragma的编译器指令，编译器后续会使⽤。

经过预处理后的 .i ⽂件中不再包含宏定义，因为宏已经被展开。并且包含的头⽂件都被插⼊到 .i文件中。所以当我们⽆法知道宏定义或者头⽂件是否包含正确的时候，可以查看预处理后的 .i ⽂件来确认

1.2.2编译

编译就是将处理后的文件进行一系列的词法分析、语法分析、语义分析及优化，生成相应的汇编代码文件，它的编译命令为：

gcc -S test.i -o test.s

假设我们有一下的一串代码，我们逐步来进行分析：

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

1.2.2.1词法分析

通过扫描器来实现，运用一种算法可以很轻松地将代码中的字符分割成一系列的记号（关键字、标识符、字面量、特殊字符等）比如上面的代码进行词法分析就会得到：

1.2.2.2语法分析

这时语法分析器会对扫描产生的记号进行语法分析，从而产生语法树，这些语法树是以表达式为节点的树，上述代码中，产生的语法树为:

这时如果出现了表达式不合法，比如括号不匹配的问题，编译器就会报告语法分析阶段的错误，在这里，各种表达式的优先级和含义将会被确定

1.2.2.3语义分析

由语义分析器来完成，即对编译器的语法层面进行分析，编译器能够做的是语义的静态分析，静态语义分析通常包括声明和类型的匹配，如果类型不同，会进行类型的转换等操作，具体如下：

这里所有的变量、赋值的结果都是整形，所以语义分析进行地很顺利

1.2.3汇编

汇编的命令：

gcc -c test.s -o test.o

汇编就是将汇编代码编程机器可执行的指令，每一个汇编语句几乎都对应着一条机器指令，就是根据汇编指令和对照表的一一对应，也不做指令优化

对于翻译环境，我们可以通过画图来进行更深刻的分析：

1.3链接

补充：在汇编完成之后，其实会生成一个符号表，符号表中包含了程序中所有的全局变量、函数等

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

比如：

我们创建了两个源文件，那么链接要完成的就是两个源文件的沟通问题

通过补充，我们知道，编译后会生成一个符号表，那么如果我们将add.c中的函数名从Add改为add时，会发生：

注意：这里报的是链接错误，详细原因为：
使用Add函数时必须要知道Add函数的地址，在链接之前，我们会将Add函数的地址搁置，如果在链接的过程中通过符号表在其它模块中找到了Add函数，就会修正搁置的地址为Add函数的真正地址，这个地址修正的过程被称为：重定义

对于全局变量，也是会在符号表中出现，原理也是如此
然而，上面只是简单讲解了编译和链接的过程，对于很多的细节，可以看《程序员的自我修养》这本书来详细了解

1.4运行环境

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

这里并不是需要了解的重点，所以我们简单了解就可以了

1.5#define符号

#define在使用时只是简单地进行替换，我们来了解一下：

1.5.1#define的使用和原理

//#define定义标识符
#define ROW 20
#define STR "hello world"
//#define定义宏
#define MAX(x,y) (x>y ? x:y)
int main()
{
	//#defime只是简单地替换
	int row = ROW;//所以这串代码会被替换为：int row = 20
	printf("row = %d\n", row);//结果为20

	char arr[20] = STR;//这串代码会被替换为：char arr[20] = "hello world"
	printf("arr = %s\n", arr);//结果为hello world

	int a = 10;
	int b = 20;
	int c = MAX(a, b);//这里会被替换成：int c = MAX(a,b)(a>b ? a:b)
	printf("c = %d\n", c);//结果为20
	return 0;
}

1.5.2#define使用的陷阱注意

既然是简单的替换，就有可能出现陷阱，比如标识符的优先级等等

我们举例子来看：

#define A 10+10
#define B 20+20
int main()
{
	int c = A * B;//这里会被替换成c = 10+ 10*20 +20，我们可以很直观地看出算法的优先级问题
	printf("c = %d\n", c);//所以结果为230
	return 0;
}

为了解决这些问题，我们可以在define定于的位置加上括号，来保证优先级：

#define A (10+10)
#define B (20+20)
int main()
{
	int c = A * B;//这里会被替换成c = (10+10) * (20+20)
	printf("c = %d\n", c);//所以结果为800
	return 0;
}

1.5.3define中#的使用

需要关注的是，define在预处理期间就被处理了，而不是在运行时

1.5.3.1一个#

会将宏参数变成对应的字符串

#define STRINGIZE(x) #x
#define TOSTRING(x) STRINGIZE(x)

int main() 
{
    const char* version = TOSTRING(1.2.3);//此时会将1.2.3转换成字符串

    printf("Version: %s\n", version);
    return 0;
}

1.5.3.2两个##

将两个宏参数合并成一个符号

#define MERGE(str1, str2) str1##str2

int main() 
{

	int class_room = 123;

	printf("%d\n", MERGE(class_, room));
	// 预处理后变成：printf("%d\n", class_room);
	//所以输出的结果为：123，因为class_room就是123
	return 0;
}

1.5.4undef

这是一个预处理指令，用于移除一个宏定义，使用方法为：

//#define定义标识符
#define ROW 20
int main()
{
	#undef ROW

	printf("ROW = %d\n", ROW);
	return 0;
}

结果如下：

这是就取消了一个宏定义