C语言进阶-程序环境和预处理（1）

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

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

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

2. 执行环境，它用于实际执行代码。

计算机时能够执行二进制指令的，但是我们写出的C语言代码是文本信息，计算机不能直接理解。

所以，翻译环境将C语言代码翻译为二进制指令（可执行程序），执行环境执行二进制的代码。

2.翻译环境

翻译环境实际上就是编译和链接的过程：

2.1 编译+链接

上图就是程序编译的过程，每个源文件（后缀为.c）都单独经过一个编译器，生成目标文件（后缀为.obj），然后这些目标文件一起和链接库在链接器的作用下生成可执行程序（后缀为.exe）。

下面我们来看个例子：

我们写了add.c和test.c两个源文件，它们经过编译之后生成目标文件add.obj和test.obj：

经过链接后生成可执行程序：

2.2 编译本身也分为几个过程

编译也分为预编译（预处理）、编译、汇编三个过程：

预编译阶段主要进行：注释的删除、#include头文件的包含、#define符号的替换等文本操作：

编译阶段：把C语言代码翻译为汇编指令，进行语法分析、词法分析、语义分析和符号汇总

汇编阶段： 把汇编代码翻译为二进制指令

而在经历了编译过程的符号汇总，汇编过程的形成符号表后，链接时主要进行：合并段表、符号标的合并和重定位

在Linux环境下，gcc编译产生的目标文件（test.o），可执行程序（test）都是按照ELF这种文件格式来存储的，而按照ELF这种格式存储时，把内存划分为一个一个的段，不同的数据在不同的段里面存储：

下面我们用前面的代码，来举例说明一下：符号汇总→生成符号表→符号表的合并与重命名的过程：

链接中合并段表，add.c和test.c在编译期间都会产生目标文件，并以ELF的格式存储，合并段表就是将它们产生的段表合一：

以上就是翻译环境的过程。下面我们简单来说一下执行环境

2.3 运行环境

程序执行的过程：

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

2. 程序的执行便开始。接着便调用main函数。

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

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

3.预编译详解

3.1 预定义符号

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

我们来使用一下：

3.2 #define

3.2.1 #define定义标识符

语法：

#define name stuff

#define可以定义任何变量，整数、字符串甚至for循环都可以：

#include<stdio.h>
#define M 100
#define STR "abc"
#define FOR for(;;)
int main()
{
  printf("%d\n", M);
  printf("%s\n", STR);
  FOR
  {
    printf("hehe\n");//死循环打印hehe
  }
  return 0;
}

上述代码中用#define定义的标识符，实际上在计算机中的预处理阶段，代码已经被替换：

#include<stdio.h>
#define M 100
#define STR "abc"
#define FOR for(;;)
int main()
{
  printf("%d\n", 100);
  printf("%s\n", "abc");
  for(;;)
  {
    printf("hehe\n");//死循环打印hehe
  }
  return 0;
}

运行结果：

使用#define CASE break;case 可以在写case语句时自动把break带上，那我们的switch语句就可以写成下面的形式：

#include<stdio.h>
#define CASE break;case
int main()
{
  int i = 0;
  scanf("%d", &i);
  switch (i)
  {
  case 1:
  CASE 2 :
  CASE 3 :
  CASE 4 :
  }
  return 0;
}

下面再来看一段代码：

// 如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠(续行符)。
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
                          date:%s\ttime:%s\n" ,\
                          __FILE__,__LINE__ , \
                          __DATE__,__TIME__ )

这段代码其实就是下面的代码：

#define DEBUG_PRINT printf("file:%s\tline:%d\t \date:%s\ttime:%s\n" ,__FILE__,__LINE__ , __DATE__,__TIME__ )

只不过这样看起来太长了，我们就把它分成4行，斜杠\是续行符，确保每一行和下一行的代码能够续上。

现在来思考一个问题：#define定义的标识符后面能不能加上分号“;”呢？

像下面一样：

#define M 100;
#define M 100

建议还是不要加，因为极有可能造成错误，比如，

#include<stdio.h>
#define M 100;
int main()
{
  int i = 1;
  if (i = 1)
    i = M;
  else
    M = 0;
  return 0;
}

运行一下会发现报错了：

为什么呢？

如果我们在用#define定义标识符时在后面加上了分号，那此时计算机中的代码应该是：

所以else没有与之匹配的if，自然就报错了。

3.2.2 #define定义宏

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

下面是宏的申明方式：

#define name( parament-list ) stuff

其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。

下面是一段用#define定义的宏，用来实现求两数较大值：

#include<stdio.h>
#define MAX(x,y) ((x)>(y)?(x):(y))
int main()
{
  int a = 10;
  int b = 8;
  int c = MAX(a, b);
  printf("%d\n", c);
  return 0;
}

这段代码在预处理阶段实际上是：

int main()
{
  int a = 10;
  int b = 8;
  int c = ((a) > (b) ? (a) : (b));
  printf("%d\n", c);
  return 0;
}

在预处理阶段，先将a，b传给MAX(x,y)得到MAX(a,b)，然后将a,b传给宏体(x)>(y)?(x):(y)得到(a)>(b)?(a):(b)。最后将(a)>(b)?(a):(b)替换到调用宏的位置。

注意：

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

这个意思就是，当我们写 #define MAX(x,y)时，MAX和它右边的括号必须紧挨在一起，中间不能有空格，像下面写法就是错误的：

#define MAX (x,y) (x)>(y)?(x):(y)

但是在调用宏的时候无所谓，可以加空格，也可以不加。

还有要注意的一点是：我们在用#define定义宏时，最好给参数都带上括号。

这是为什么呢？看下面一段代码（求一个数的平方）：

#include<stdio.h>
#define SQUART(x) x*x
int main()
{
  int a = 3;
  int r = SQUART(a + 3);
  printf("%d\n", r);
  return 0;
}

我们期望得到的是（3+3）*（3+3）= 36，但是结果呢？

实际上将参数x替换成a+3进行的是：a+3*a+3的计算，3+9+3=15。

而要得到正确结果，只需要给参数加上括号就行了：

此时，请再来思考一个问题，仅仅给参数加上括号就能得到期望的值吗？

再看一段代码：

#include<stdio.h>
#define SQUART(x) (x)+(x)
int main()
{
  int a = 3;
  int r = 10 * SQUART(a);
  printf("%d\n", r);
  return 0;
}

我们期望得到的值是10*6=60，但是结果呢？

实际上替换后，进行的是10*(a)+(a) = 10*(3)+(3) = 33。

此时要得到期望的结果就要给宏体的整体加上括号：

总结一下：

所以用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用。

3.2.3 #define 替换规则

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

1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，        它们首先被替换。

2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。

3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，

   就重复上述处理过程。

关于#define的替换规则，我们在学了上述内容应该有所体会，

这里我们再拿上文中的一段代码举例说明一下：

#include<stdio.h>
#define SQUART(x) ((x)*(x))
int main()
{
  int a = 3;
  int r = SQUART(a + 3);
  printf("%d\n", r);
  return 0;
}

这里在替换时，是直接将a+3替换进去的，而不是：先算出a+3的值，再替换进去

#include<stdio.h>
#define SQUART(x) ((x)*(x))
int main()
{
  int a = 3;
  int r = ((a+3)*(a+3));
  printf("%d\n", r);
  return 0;
}

注意：

1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。

示例：

#include<stdio.h>
#define SQUART(x) ((x)*(x))
#define M 3
int main()
{
  int r = SQUART(M+3);
  printf("%d\n", r);
  return 0;
}

结果是：36

2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

示例：

字符串常量中的M不被替换。