程序的环境和预处理

1.程序的翻译环境

在翻译环境中，源代码被转换成可执行的机器指令。

在翻译环境中，程序经过编译（预编译（预处理）、编译、汇编）生成目标文件，目标文件和链接库通过链接生成可执行文件。

在linux环境中，通过gcc编译器可以得到程序编译和链接过程中每一步的结果。

	gcc指令	生成的文件	完成的操作
预编译（预处理）	gcc test.c -E > test.i	test.i	1.完成了头文件的包含#include； 2.#define定义的符号和宏的替换； 3.删除了注释 都是文本操作
编译	gcc test.i -S	test.s	把C语言代码转化为汇编代码 1.语法分析 2.词法分析 3.语义分析 4.符号汇总（汇总全局符号）
汇编	gcc test.s -c	test.o (test.obj)	1.生成符号表 2.把汇编代码转换成了机器指令（二进制指令）
链接			把多个目标文件和链接库进行链接 1.合并段表 2.符号表的合并和重定位

test.o和可执行文件都是elf格式的，在这种格式中，文件将被分成多个段表，需要专门的工具来阅读elf文件。

2.程序的运行环境（执行环境）

程序执行的过程：

1.程序必须载入到内存中。在有操作系统的环境中，一般由操作系统完成。在独立环境中，程序的载入必须由手工安排，也可能是通过可执行代码置入只读内存来完成。

2.程序执行开始，调用main函数

3.开始执行程序代码，这个时候程序将使用一个堆栈，存储函数的局部变量和返回地址。程序同时可以使用静态内存，存储于静态内存中的变量在整个程序的执行过程中一直保留它们的值。

4.终止程序。正常终止main函数；也可能是意外终止。

3.预处理详解

3.1预定义符号

#include <stdio.h>

int main() {
	printf("%s\n", __FILE__);//所在文件路径
	printf("%d\n", __LINE__);//所在行数
	printf("%s\n", __DATE__);//当前日期
	printf("%s\n", __TIME__);//当前时间
	printf("%s\n", __FUNCTION__);//这段代码在哪个函数中
	//printf("%s\n", __STDC__);//支持ANSIC，其值为1，否则未定义
	return 0;
}

3.2#define定义的标识符（符号和宏）

#define定义的标识符在预处理就被相应的文本替换了，在这个过程中，没有任何计算

//定义符号
#define M 100
#define CASE break;case//可以不用再写break
#define FOR for(;;)//死循环

//定义宏
// 宏可以将参数替换到文本中
//在定义宏时，括号很重要，否则就会因为运算符的优先级而出现错误结果
//所以不论是变量还是整体都要加上括号
//#define的替换规则
//1.在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果有，它们首先被替换
//2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值替换
//3.最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号，如果有，就重复上述过程
//notice
//1.宏参数和#define定义中可以出现其他#define定义的变量，但对于宏，不能出现递归
//2.当预处理器搜索#define定义的符号时，字符串常量中的字符不被搜索

#include <stdio.h>
#define MAX(a,b) ((a>b)?(a):(b))
#define SZ(class) sizeof(class)
int main() {
	int a = 5;
	int b = 3;
	printf("%d\n", MAX(a, b));
	int sz = SZ(int);
	printf("%d\n", sz);
	return 0;
}

3.3#和##

//在#define定义中，#能把参数插入到字符串中，##能将两个符号连接成一个符号，注意##连接的是文本，不是字符串，并且可以多个##一起使用

#include <stdio.h>
#define PRINT(x) printf("the value of "#x" is %d\n",x)
#define CAT(m,n) m##n
int main() {
	int a = 0;
	int b = 1;
	int c = 2;
	PRINT(a);
	PRINT(b);
	PRINT(c);
	int value = 7;
	printf("%d\n", CAT(va, lue));
	return 0;
}

3.4带副作用的宏参数

#include <stdio.h>
#define MAX(a,b) ((a>b)?(a):(b))
int main() {
	//类似a++这样的代码称为是有副作用的，因为在运行完后a的值也发生了改变
	//副作用就是表达式求值产生的永久性效果
	//当宏参数在宏的定义中出现超过了一次时，使用带有副作用的宏参数，就会出现意料之外的结果
	int a = 1;
	int b = 2;
	printf("MAX = %d\n", MAX(a++, b++));
	return 0;
}

3.5宏和函数对比

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

命名约定：#define定义的全大写，函数名不要全部大写 

3.6#undef（移除一个定义）

#include <stdio.h>

#define M 100
int main() {
	printf("%d\n", M);
#undef M
	printf("%d\n", M);
	return 0;
}

3.7命令行定义

一些C语言的编译器提供了一种能力，允许在命令行定义符号。

在linux环境下，使用gcc编译器：

gcc test.c -D M=10//定义符号M为10，可用于改变数组大小等

3.8条件编译

#include <stdio.h>
#define __DEBUG__

int main() {
#ifdef __DEBUG__//可以写成#if defined()
	printf("1\n");
#endif
#ifndef __TEST__//#if !defined()
	printf("2\n");
#endif
#if 0
	printf("3\n");
#elif 2
		printf("4\n");
#else
	printf("5\n");
#endif
	return 0;
}//以上指令均可以嵌套

3.9文件包含

1.本地文件包含

#include "head.h"

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

2.库文件包含

#include <stdio.h>

查找策略：直接在库函数头文件所在位置查找

对于多次包含的头文件，在编译的时候，会将这些头文件包含全部替换成文本，这就使得代码在预处理之后变得非常的冗长，有两种方法可以使头文件重复包含也只替换一次文本：

//在头文件中加入指令
#pragma once

//或在头文件开头加入
#ifndef __TEST__
#define __TEST__
...
#endif

3.10其他预处理指令