程序的编译、链接与预处理过程

程序的编译、链接、预处理过程

---

1.程序的翻译环境、执行环境

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

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

---

2.程序的编译与链接过程

翻译环境的理解：源代码被转换为可执行的机器指令的环境

编译的四个阶段：预处理、编译、汇编、链接

预处理阶段进行：宏替换、条件编译、去掉注释、展开头文件

编译：检查语法生成汇编代码

汇编：将汇编代码编译成机器码，生成目标文件

链接：将目标文件链接在一起，生成可执行文件

1. 预处理 选项 gcc -E test.c -o test.i 预处理完成之后就停下来，预处理之后产生的结果都放在test.i文件中
2. 编译 选项 gcc -S test.c 编译完成之后就停下来，结果保存在test.s中
3. 汇编 gcc -c test.c 汇编完成之后就停下来，结果保存在test.o中
4. 链接 合并段表、符号表、重定位，形成可执行程序

扩展：程序执行的过程

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

---

3.对于预处理的剖析

3.1 预处理符号的了解

这些预定义符号都是语言内置的：

一：_ FILE_ //进行编译的源文件

二：_ LINE_ //文件当前的行号

三：_ DATE_ //文件被编译的日期

四：_ TIME_ //文件被编译的时间

五：_ STDC_ //如果编译器遵循ANSI C，其值为1，否则未定义

举例：printf(“file:%s line:%d\n”, _ FILE_, _ LINE_);

---

3.2 对#define的剖析

#define原型：

//#define原型：#define name stuff
#define MAX 1000
#define reg register          //为 register这个关键字，创建一个简短的名字
#define do_forever for(;;)     //用更形象的符号来替换一种实现
#define CASE break;case        //在写case语句的时候自动把 break写上
// 如果定义的stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠(续行符)
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
                          date:%s\ttime:%s\n", \
						  __FILE__,__LINE__ ,  \
						  __DATE__,__TIME__ )

对于#define定义的思考：在define定义标识符的时候，要不要在最后加上 ;
建议不要加上，如下例子：容易出现语法错误

#deinf Max 100;
if(condition)
 	max = MAX;//这里替换就变成了max=100;;---有两个;会发生语法错误
else
 	max = 0;

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

//正常使用宏定义
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define MAX(x,y) ((x)>(y)?(x):(y))//MAX(x,y)这是一个宏函数，后面计算最好每个参数都带上()，否则替换时可能计算顺序会改变
int main()
{
	int a = 10;
	int b = 20;
	int max = MAX(a, b);
	printf("a和b中最大的值是：%d\n", max);
	return 0;
}

宏定义存在的问题：它是直接替换，没有考虑优先级和结合性问题

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define int(x) x+x //正确写法#define int(x) ((x)+(x))
int main()
{
	int n = int(2);
	printf("%d\n", 10 * int(2));//替换为10*2+2
    //我们期望得到的结果是40，但是打印结果为22
	return 0;
}

从上面的例子就可以很好的看出，宏定义存在的问题就容易导致运算顺序改变

#define替换的规则：直接替换过去，其他不管

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

---

3.3 #和##的了解

案例思考：如何把参数插入到字符串中？

1. 使用 # ，把一个宏参数变成对应的字符串
2. 使用##，可以把位于它两边的符号合成一个符号

//#的使用
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define PRINT(n) printf("the value of "#n" is %d\n",n);//这个#n就是把参数n变成一个字符串，比如传入a，就替换成"a"
int main()
{
	int a = 10;
	int b = 20;
	PRINT(a);
	PRINT(b);
	return 0;
}

//##的使用
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define CAT(name1,name2) name1##name2
int main()
{
	int Class100 = 10000;
	printf("Class100=%d\n", CAT(Class, 100));//CAT(Class,100)就是把两边符号合成一个符号，即Class100
	return 0;
}

---

3.4 带副作用的宏参数

当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用(自加自减等)，那么你在使用这个宏的时候就可能出现危险，导致不可预测的后果。副作用就是表达式求值的时候出现的永久性效果

x+1;//不带副作用
x++;//带有副作用

//MAX宏可以证明具有副作用的参数所引起的问题
#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
int main()
{
    int x = 5;
	int y = 8;
	int z = MAX(x++, y++);
	printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是:x=6 y=10 z=9  
    //解释：宏替换进入#define为：(x++)>(y++)?(x++):(y++)，因为执行x++，y++，得：x=6，y=9，因为y更大，则得z=9，然后y++，y为10
    //最终a=6，y=10,z=9
}

---

3.5 宏和函数的对比

属性	#define定义宏	函数
代码长度	每次使用时，宏代码都会被插入到程序中。除了非常 小的宏之外，程序的长度会大幅度增长	函数代码只出现于一个地方；每 次使用这个函数时，都调用那个 地方的同一份代码
执行速度	更快	存在函数的调用和返回的额外开 销，所以相对慢一些
操 作 符 优 先 级	宏参数的求值是在所有周围表达式的上下文环境里， 除非加上括号，否则邻近操作符的优先级可能会产生 不可预料的后果，所以建议宏在书写的时候多些括号	函数参数只在函数调用的时候求 值一次，它的结果值传递给函 数。表达式的求值结果更容易预测
带 有 副 作 用 的 参 数	参数可能被替换到宏体中的多个位置，所以带有副作 用的参数求值可能会产生不可预料的结果	函数参数只在传参的时候求值一 次，结果更容易控制
参 数 类 型	宏的参数与类型无关，只要对参数的操作是合法的， 它就可以使用于任何参数类型	函数的参数是与类型有关的，如 果参数的类型不同，就需要不同 的函数，即使他们执行的任务是 不同的
调 试	宏是不方便调试的	函数是可以逐语句调试的
递 归	宏是不能递归的	函数是可以递归的

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define MAX(x,y) ((x)>(y)?(x):(y))
int get_max(int x, int y)
{
	return x > y ? x : y;
}

int main()
{
	int a = 3;
	int b = 5;
	//使用宏---直接替换运算，比较快
	int m = MAX(a, b);
	printf("%d\n", m);//打印5
	//使用函数---经过：函数调用+逻辑运算+函数返回，速度慢
	int mm = get_max(a, b);
	printf("%d\n", mm);//打印5
}

总结：宏用于简单运算—函数用于复杂的运算—主要还是用函数，宏容易错误

命名约定：宏名称全部用大写—函数名全部用小写

宏移除方法：#undef NAME—如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除

---

3.6 预处理中的条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件编译指令

比如说：调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译

条件编译常见：单分支条件编译、多分支条件编译、判定是否被定义、嵌套条件编译

//单分支条件编译
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
	for (int i = 0; i < 10; ++i)
	{
		//条件编译,预处理阶段执行
#if 1//条件编译开始，满足条件为0就执行
		printf("%d\n", i);
#endif//条件编译结束
	}
	return 0;
}

//多分支条件编译
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define M 100
int main()
{
#if M<100
	printf("M<100\n");
#elif M==100
	printf("M=100\n");
#else
	printf("M>100\n");
#endif
	return 0;
}

//判断是否被定义
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define M 0
int main()
{
#if defined(M)//反面#if !defined(M)
	printf("M存在\n");
#endif

#ifdef M
	printf("M存在\n");
#endif
	return 0;
}

//嵌套条件编译
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define M 100
#define N 20
int main()
{
#if defined(M)
   #ifdef N
	printf("M和N都存在\n");
   #endif
   #if !defined N
	printf("M存在，N不存在\n");
   #endif
#endif
	return 0;
}

---

4.文件包含

库文件包含：#include<filename.h>—库里的头文件

本地文件包含：#include “filename”—自己写的头文件

VS环境的标准头文件的路径：C:\Program Files (x86)\Microsoft Visual Studio\VC\include

Linux环境的标准头文件的路径：/usr/include

文件包含防止重复包含的方法：旧编译器使用条件编译来处理---新编译器使用#pragma once来处理

举例：

1. comm.h和comm.c是公共模块
2. test1.h和test1.c使用了公共模块
3. test2.h和test2.c使用了公共模块
4. test.h和test.c使用了test1模块和test2模块
5. 这样最终程序中就会出现两份comm.h的内容。这样就造成了文件内容的重复
   
   

这种情况我们就可以使用条件编译或者#pragma once来处理这个问题