程序的翻译环境和执行环境
在ANSI C的任何一种实现中，存在两个不同的环境
第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。
第2种是执行环境，它用于实际执行代码
详解编译+链接
翻译环境
组成一个程序的每个源文件通过编译过程分别转换成目标代码（object code）。
每个目标文件由链接器（linker）捆绑在一起，形成一个单一而完整的可执行程序。
链接器同时也会引入标准C函数库中任何被该程序所用到的函数，而且它可以搜索程序员个人的程序库，将其需要的函数也链接到程序中
编译本身也分为几个阶段
注意 ：我们这里使用Linux系统上的gcc编译器
编译本身也分为几个阶段，测试代码如下
sum.c
1. int g_val = 2016; 2. void print(const char *str) 3. { 4. printf("%s\n", str); 5. }
test.c
1. #include <stdio.h> 2. int main() 3. { 4. extern void print(char *str); 5. extern int g_val; 6. printf("%d\n", g_val); 7. print("hello bit.\n"); 8. return 0; 9. }
预处理阶段：
在gcc编辑器上进行的操作：gcc -E test.c -o test.i，·-E 是进行预处理操作，-o指定输出到test.i文件（不会自动生成，需要指定输出），该阶段进行的操作为：1.#include头文件的包含；2.#define定义的符号的替换和删除操作；3.注释的删除（1、2为预编译指令操作；3为文本操作）。
编译阶段：
在gcc编辑器上进行的操作：gcc -S test.i (进行编译操作，执行后自动生成test.s文件，也可以进行指定)，该阶段进行的操作为：把C语言代码翻译成汇编代码、进行语义分析、词法分析、语义分析、符号汇总
汇编阶段：
在gcc编辑器上进行的操作：gcc -c test.c(进行汇编操作后，会自动生成test.o文件，也可以进行指定)；该阶段进行的操作为：把汇编代码翻译成了二进制指令（存放在目标文件中）、形成符号表。
链接阶段：
1.合成段表
2.符号表的合并和符号表的重定位
关于符号汇总还可结合下图进行观看
那么我们如何查看编译期间的每一步发生了什么呢？
比如我们有以下这个代码
test.c
1. #include <stdio.h> 2. int main() 3. { 4. int i = 0; 5. for(i=0; i<10; i++) 6. { 7. printf("%d ", i); 8. } 9. return 0; 10. }
查看步骤如下
1. 预处理 选项 gcc -E test.c -o test.i
预处理完成之后就停下来，预处理之后产生的结果都放在test.i文件中。
2. 编译 选项 gcc -S test.c
编译完成之后就停下来，结果保存在test.s中。
3. 汇编 gcc -c test.c
汇编完成之后就停下来，结果保存在test.o中。
当我们编译完成后了，就会生成我们的可执行程序
运行环境
程序执行的过程：
1. 程序必须载入内存中。在有操作系统的环境中：一般这个由操作系统完成。在独立的环境中，程序 的载入必须由手工安排，也可能是通过可执行代码置入只读内存来完成。
2. 程序的执行便开始。接着便调用main函数。
3. 开始执行程序代码。这个时候程序将使用一个运行时堆栈（stack），存储函数的局部变量和返回 地址。程序同时也可以使用静态（static）内存，存储于静态内存中的变量在程序的整个执行过程 一直保留他们的值。
4. 终止程序。正常终止main函数；也有可能是意外终止。
预处理（预编译）详解
预定义符号
__FILE__ //进行编译的源文件
__LINE__ //文件当前的行号
__DATE__ //文件被编译的日期
__TIME__ //文件被编译的时间
__STDC__ //如果编译器遵循ANSI C，其值为1，否则未定义
这些预定义符号都是语言内置的。
举个例子：
1. // printf("%s\n", __FILE__); 2. // printf("%d\n", __LINE__);
用我们vs编译器进行编译后 ，结果如下
我们再用gcc进行预编译，当我们打开我们的预编译
我们发现test.i的文件里已经变为我们所需要输出的内容
我们再举个例子：
1. int main() 2. { 3. printf("%s\n", __FILE__); 4. printf("%d\n", __LINE__); 5. printf("%s\n", __DATE__); 6. printf("%s\n", __TIME__); 7. //printf("%d\n", __STDC__);//当前VS是不支持ANSI C 8. return 0; 9. }
运行结果如下：
#define
#define 定义标识符
语法：
#define name stuff
举个例子：
1. //#include <stdio.h> 2. //#define M 100 3. //#define STR "abc" 4. //#define FOR for(;;) 5. //int main() 6. //{ 7. // printf("%d\n", M); 8. // printf("%s\n", STR); 9. // FOR; 10. // return 0; 11. //}
运行结果如下：
我们再转入gcc编译器看一下预编译
注意：在define定义标识符的时候，不要再最后加上 '；'
例如：
1. #define MAX 1000; 2. #define MAX 1000
当这行代码遇上下列代码
1. if(condition) 2. max = MAX; 3. else 4. max = 0;
这里就会出现语法错误。
总结：建议不要加上;,这样容易导致问题
#define 定义宏
#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏（macro）或定义宏（define macro）。
下面是宏的申明方式：
#define name( parament-list ) stuff
其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中
例如：
1. //#define MAX(x, y) ((x)>(y)?(x):(y)) 2. //int main() 3. //{ 4. // int a = 5; 5. // int b = 6; 6. // int c = MAX(a, b); 7. // printf("%d",c); 8. //}
运行结果如下
我们再用gcc进行预编译，结果如下
这里已经进行了替换
注意：
参数列表的左括号必须与name紧邻。
如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分
例如：
#define SQUARE( x ) x * x
这个宏接收一个参数 x .，如果在上述声明之后，你把
SQUARE( 5);
置于程序中，预处理器就会用下面这个表达式替换上面的表达式：
5 * 5
警告： 这个宏存在一个问题，观察下面的代码段：
1. int a = 5; 2. printf("%d\n" ,SQUARE( a + 1) );
乍一看，你可能觉得这段代码将打印36这个值。 事实上，它将打印11，为什么呢？
替换文本时，参数x被替换成a + 1,所以这条语句实际上变成了：
printf ("%d\n",a + 1 * a + 1 );
这样就比较清晰了，由替换产生的表达式并没有按照预想的次序进行求值。 在宏定义上加上两个括号，这个问题便轻松的解决了。
我们再看一个例子：
#define DOUBLE(x) (x) + (x)
定义中我们使用了括号，想避免之前的问题，但是这个宏可能会出现新的错误。
1. int a = 5; 2. printf("%d\n" ,10 * DOUBLE(a));
这将打印什么值呢？
看上去，好像打印100，但事实上打印的是55，我们发现替换之后：
printf("%d\n",10 *(5) +(5));
乘法运算先于宏定义的加法，所以出现了 55，这个问题，的解决办法是在宏定义表达式两边加上一对括号就可以了
#define DOUBLE( x) ( ( x ) + ( x ) )
总结：
所以用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用。
#define 替换规则
在程序中扩展#define定义符号和宏时，需要涉及几个步骤。
1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。
2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。
3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。
注意：
1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。
#和##
如何把参数插入到字符串中？
我们先看这样一段代码
1. char* p = "hello ""bit\n"; 2. printf("hello"" bit\n"); 3. printf("%s", p);
运行结果如下
我们发现字符串是有自动连接的特点的。
那我们是不是就可以这样写代码
1. #define PRINT(FORMAT, VALUE) printf("the value is "FORMAT"\n", VALUE) 2. int main() 3. { 4. PRINT("%d", 10); 5. }
运行结果如下：
这里只有当字符串作为宏参数的时候才可以把字符串放在字符串中。
另外一个技巧是：使用 # ，把一个宏参数变成对应的字符串
例如：
1. #define PRINT(FORMAT, VALUE) printf("the value of " #VALUE " is "FORMAT "\n", VALUE) 2. int main() 3. { 4. int i = 10; 5. PRINT("%d", i + 3); 6. }
代码中的 #VALUE 会预处理器处理为： "VALUE" ，运行结果如下
## 的作用
##可以把位于它两边的符号合成一个符号。
它允许宏定义从分离的文本片段创建标识符
例如：
1. //#define CAT(x,y) x##y 2. //int main() 3. //{ 4. // int Class110 = 2024; 5. // printf("%d\n", CAT(Class, 110)); 6. // printf("%d\n", Class110); 7. // return 0; 8. //}
运行结果如下：
注意：这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。
