C语言--程序环境与预处理

前言

我们在写一个C语言程序的时候，时常会创建一个后缀为**.c**的文件，这个文件究竟是怎样变成可执行的程序的呢？其实是通过编译和链接这样的过程来实现。本篇文章我们就将围绕着编译和链接是什么来展开。

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

在ANSI C的任何一种实现中，存在两个不同的环境：
第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。
第2种是执行环境，它用于实际执行代码。
我们可以通过图像来进一步理解：

翻译环境

我们先来看在翻译环境下做了什么事。
其实翻译环境下主要由两部分构成：编译器和链接器。

在一个大型工程中，可能会需要成百上千个像test.c这样的源文件，它们每个都单独经过编译器生成目标文件，再一起通过链接器形成可执行的程序。

编译和链接

由于VS是一个集成开发环境，集成很多功能，ctrl+5，VS就将很多细节一起执行了，我们无法观察到具体到每一步的细节，所以我们使用gcc这个编译器来演示。
1,编译
编译本身可以分为以下三个阶段：

1. 预处理
   1.宏替换 2.删除注释
   3.头文件的展开 4.条件编译

2. 编译
   该过程是为了将C语言翻译成汇编代码
   1.语法分析 2.词法分析
   3.语义分析 4.符号汇总

3. 汇编
   该过程形成符号表，将汇编代码转换成二进制代码。

2,链接
我们以写一个add函数为例（假设分两个源文件来书写）

具体的实现过程如图

值得一提的是，如果函数被static修饰，那么这个函数变量就不会放到符号表里，自然也就找不到这个函数了。

运行环境

程序执行的过程：

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

预处理详解

我们先来看下各种预定义符号

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

这些预定义符号都是语言内置的
我们在VS环境下观察一下这些预定义符号

int main()
{
	int i = 0;
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	for (i = 0; i < 10; i++)
	{
		printf("%d----%s, %s, %s, line=%d\n", arr[i], __FILE__, __DATE__, __TIME__, __LINE__);
	}

	return 0;
}

打印结果如图
我们可以看到文件位置，时间，行号等都被依次打印了出来，这些符号都是能直接使用的。

我们再来看下__STDC__ 在VS环境下的效果

int main()
{
	printf("%d\n", __STDC__);

	return 0;
}

我们发现程序出现错误，并给出了如下信息

可见，VS不是严格遵循C标准的。但在gcc环境下是可行的。

#define

#define定义标识符

这个用法很常见，看下面这几个例子

#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 MAX 1000;
#define MAX 1000
if(condition)
max = MAX;
else
max = 0;

这种情况下代码就会出现语法错误。

#define 定义宏

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

下面是宏的申明方式：
#define name( parament-list ) stuff
其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。

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

看下面这段代码

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

 int main()
 {
     printf("%d\n", SQUARE(1+7));

     return 0;
 }

宏的作用就是将main函数内的SQUARE(1+7)替换为8*8

但是如果我们去掉括号，看下面这段类似的代码

 #define SQUARE(x)  x*x

 int main()
 {
     printf("%d\n", SQUARE(1+7));

     return 0;
 }

打印结果就变成了15。

这是由于SQUARE(1+7)被替换为1+71+7，又因为的优先级高于+，所以先执行7*1再执行加法，

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

#define替换规则

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

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

#和##

首先我们来看这段代码：

char* p = "hello ""world\n";
printf("hello"" world\n");
printf("%s", p);

打印结果我们发现为hello world，由此可见，字符串是有自动连接的特点的。
我们来看这段代码

 #define print_format(num, format) \
             printf("the value of "#num" is "format, num)

 int main()
 {
     int a = 10;
     print_format(a, "%d\n");
     //printf("the value of a is %d\n", a);

     int b = 20;
     print_format(b, "%d\n");
     //printf("the value of b is %d\n", b);

     float f = 3.14f;
     print_format(f, "%f\n");
     //printf("the value of f is %f\n", f);

     return 0;
 }

宏替换后的代码如图

我们可以发现
#的作用是把一个宏参数变成对应的字符串
##的作用是可以把位于它两边的符号合成一个符号。它允许宏定义从分离的文本片段创建标识符。

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

带副作用的宏参数

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

什么是副作用呢？
比较这两个式子

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

对于第一个语句执行完后，x的值是不变的，但第二个语句执行后，x的值是加了1的。

宏和函数的对比

我们用函数和宏分别来实现比较大小的功能，代码如下

 #define MAX(X,Y) ((X)>(Y)?(X):(Y))

 int Max(int x, int y)
 {
     return x>y?x:y;
 }

 #define M 100


 int main()
 {
     int m = MAX(M, 5);
     printf("%d\n", m);

     m = Max(3,5);
     printf("%d\n", m);
     return 0;
 }

这两种方法都能运行，但是实际上，在执行比较简短的运算时，宏的效率要更高一些。
这是因为函数在调用时会做一些额外的工作。

1. 函数调用前准备（传参，函数栈帧空间的维护）
2. 主要运算
3. 函数返回，返回值的处理，函数栈帧的销毁。

更为重要的是函数的参数必须声明为特定的类型。
所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以用于>来比较的类型。
宏是类型无关的。

当然，宏也存在劣势的地方：

1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序
   的长度。
2. 宏是没法调试的。
3. 宏由于类型无关，也就不够严谨。
4. 宏可能会带来运算符优先级的问题，导致程容易出现错。

宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。
看下面这个例子

#define MALLOC(num, type)\
(type *)malloc(num * sizeof(type))
...
//使用
MALLOC(10, int);//类型作为参数
//预处理器替换之后：
(int *)malloc(10 * sizeof(int));

我们把以上的区别汇成一个表来比较，如图。

命名习惯

为了便于区分，我们习惯把宏名全部大写，函数名不全部大写。

命令行定义

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

#include 
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环境下演示编译指令如下：

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

条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件
编译指令。
比如调试性的代码，我们如果既不想删除又觉得保留碍事，我们可以采用选择性编译。

int main()
{
int i = 0;
int arr[10] = {0};
for(i=0; i<10; i++)
{
arr[i] = i;
#ifdef __DEBUG__
printf("%d\n", arr[i]);//为了观察数组是否赋值成功。
#endif //__DEBUG__
}
return 0;
}

常见的条件编译指令有如下几种：

1.
#if 常量表达式
//...
#endif
//常量表达式由预处理器求值。
如：
#define __DEBUG__ 1
#if __DEBUG__
//..
#endif
2.多个分支的条件编译
#if 常量表达式
//...
#elif 常量表达式
//...
#else
//...
#endif
3.判断是否被定义
#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol
4.嵌套指令
#if defined(OS_UNIX)
#ifdef OPTION1
unix_version_option1();
#endif
#ifdef OPTION2
unix_version_option2();
#endif
#elif defined(OS_MSDOS)
#ifdef OPTION2
msdos_version_option2();
#endif
#endif

文件包含

我们在之前书写三子棋，扫雷这类代码时，采用了引用本地文件和库文件的方式，如

#include  --库函数头文件
#include "test.c" --本地文件

编译器在查找文件的时候采取的是先在源文件所在目录下查找，如果该头文件未找到，就像查找库函数头文件一样在标准位置查找头文件的方式。
那么我们思考：是不是对于库文件我们也可以使用""的形式包含？
答案是可以的，但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了

嵌套文件包含

我们在完成一个大型工程的时候，难免会出现文件嵌套包含的情况，这种时候就可能出现重复包含头文件的情形。这样就造成了文件内容的重复。

如何让解决这个问题呢？
答案是:条件编译

我们在每个头文件开头这样写：

#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif //__TEST_H__

或者写成这样

#pragma once

这样就可以避免文件的重复引入。

好了，以上就是本章的全部内容了，如有出入，欢迎指正。