程序环境和预处理

1.翻译环境和执行环境

在ANSI C(标准C)的任何一种实现中，存在两个不同的环境

1.1翻译环境

在这个环境中源代码被翻译成可执行的机器语言

c语言中源文件的后缀为.c，经过编译器处理，翻译成后缀为.obj的目标文件（vs编辑器下），最后经过链接器链接生成.exe后缀的可执行程序。



那编译器是怎么工作的呢？

1.2翻译的几个阶段

1. 预处理：

注释的删除
头文件的包含（#include）
宏的替换（#define）
预处理指令的执行
预处理完.c后缀文件后生成后缀.i文件（gcc test.c -E -o test.i）

2. 编译

将C语言代码翻译成汇编指令
语法分析，词法分析,语义分析,符号汇总。
编译完.i后缀文件生成.s后缀文件（gcc test.i -S test.s）

3. 汇编

将汇编指令翻译成二进制指令
形成符号表
汇编完后.s文件生成.o后缀文件（gcc下目标文件后缀为.o，目标文件都存放二进制指令）

4. 链接

合成段表
符号表的合并和符号表的重定位
形成.exe可执行程序

1.3执行环境

程序执行的过程

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

2.预处理详解

2.1预定义符号

预定义符号是C标准定义的宏定义符号，如：

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

2.2 #define

2.2.1 #defien定义标识符

语法
#define name stuff

#define A 100                   //标识A为100
#define CASE break;case        //在写case语句的时候自动把 break写上。 
#define p int*                 //为int*类型创建一个简单的名字

注：末尾千万不能加；不然可能会出错。

2.22 #define定义宏

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

下面是宏的申明方式

#define name( parament-list ) stuff
//其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中

注意：

参数列表的左括号必须与name紧邻，如果两者之间存在任何空白，参数列表就会被解释为stuff的一部分。

在宏定义的时候要注意使用括号，不然会造成意向不到的后果
如：

#define SQUARE(x) x*x

int main()
{
	printf("%d", SQUARE(4+1));
	return 0;
}

你可能预期的输出是25，但是

这是因为替换之后是这样的

#define SQUARE(x) 4+1*4+1

所以在我们定义宏的时候要用括号括起来

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

int main()
{
	printf("%d", SQUARE(4+1));
	return 0;
}

2.2.3 #define替换规则

在程序中扩展#define定义符号和宏时，需要涉及几个步骤。

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

注意：

宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

2.2.4 #和##

如何把参数插入到字符串中？

首先我们要知道字符串是有自动连接功能的

int main()
{
	printf("hello" " " "world");
	return 0;
}

那我们可以这样实现把参数插入到字符串中

#define PRINTF(str) printf("这后面将插入一个字符串 "str" 这前面将插入一个字符串\n")

int main()
{
	PRINTF("插入的字符串");
	return 0;
}

不过这里的参数只能是字符串类型的，所以这里我们有一个方法，使用#，把一个宏参数变为字符串。

#define PRINTF(FORMAT,VALUE) printf("the value of " #VALUE " is " FORMAT,VALUE)

int main()
{
	int i = 1;
	PRINTF("%d", i + 1);
	return 0;
}

##的作用

##可以把位于它两边的符号合成一个符号。
它允许宏定义从分离的文本片段创建标识符。

#define ADD_TO_SUM(num, value) \
 sum##num += value;
int main()
{
	int sum1 = 0;
	ADD_TO_SUM(1, 5);
	printf("%d", sum1);
	return 0;
}

替换之后是

#define ADD_TO_SUM(num, value) sum1 += 5;

注：
这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。

2.2.5 带副作用的宏参数

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

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

#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);//输出的结果是什么？
	return 0;
}

2.2.6 宏和函数对比

与函数相比，宏应用于简单的运算更有优势，原因有二：

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。 所以宏比函数在程序的规模和速度方面更胜一筹。
2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以用于>来比较的类型。宏是类型无关的。

但是宏也有缺点：

1. 每次使用宏的时候，一份宏定义的代码将插入到程序中，除非宏比较短，否则可能大幅度增加程序的长度。
2. 宏的代码在预处理阶段就替换成宏的内容对应的代码，所以在调试的时候，执行的代码和你在源代码中所看到的代码是不一致的。
3. 宏由于类型无关，也就不够严谨。
4. 宏可能会带来运算符优先级的问题，导致程序容易出现问题。

宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。

#define MALLOC(num, type)\
 (type *)malloc(num * sizeof(type))

int main()
{
	int* a = MALLOC(10, int);
	return 0;
}

2.2.7 命名约定

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

把宏名全部大写
函数名不要全部大写

2.3 #undef

这条指令用于移除一个宏定义。

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

2.4命令行定义

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

#include <stdio.h>
int main()
{
    int array [ARRAY_SIZE];
    int i = 0;
    for(i = 0; i< ARRAY_SIZE; i ++)
   {
        array[i] = i;
   }
    for(i = 0; i< ARRAY_SIZE; i ++)
   {
        printf("%d " ,array[i]);
   }
    printf("\n" );
    return 0;
}

编译指令

//linux 环境演示
gcc -D ARRAY_SIZE=10 programe.c

2.5 条件编译

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

常见的条件编译指令：

//1.
#if 常量表达式
	//...
#endif
//常量表达式求值

例子：

#include<stdio.h>
int main()
{
#define n 1
#if n
	printf("%d\n", n);
#endif
	return 0;
}

2.多个分支的条件编译
#if 常量表达式
 //...
#elif 常量表达式
 //...
#else
 //...
#endif

#include<stdio.h>
int main()
{
#define n 5
#if(n==3)
	printf("%d\n", 3);
#elif(n==5)
	printf("%d\n", 5);
#else
	printf("%d\n", 0);
#endif
	return 0;
}

2.6 文件包含

我们已经知道，·#include指令可以使另外一个文件被编译，就像该文件出现于#include指令的地方一样。这种替换的方式文件简单：预处理器删除这条指令，并包含文件的内容替换；这样一个源文件被包含10次，那就实际被编译10次。

2.6.1文件包含的方式

（1）本地文件包含

#include "filename"

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

#include <stdio.h>

查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。

对于库文件也可以使用""的形式包含，因为头文件查找是现在源文件所在目录查找，然后再库函数文件的位置去查找；但是这样做的效率会降低，同时不容易区分是库文件还是本地文件。

2.6.2 嵌套文件包含

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

解决方案：

/每个头文件的开头写：
#ifndef __TEST_H__//未定义执行
#define __TEST_H__//定义
	//头文件的内容
#endif

或者懒人版

#pragma once

3.其他预处理指令

#error
#pragma
#line
#pragma pack()