17 C语言进阶程序的编译(预处理操作)

程序环境和预处理

• 程序的翻译环境和执行环境
• 详解编译+链接
  • 翻译环境
  • 编译还可以分为几个阶段
  • 编译每个阶段的事情
  • 链接做的事情
  • 运行环境
• 预处理详解
  • 预定义符号
  • [#define 预处理指令](##define 预处理指令)
  • #undef
  • 命令行定义
  • 条件编译
  • 文件包含
  • 其他预处理指令

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

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

第一种是翻译环境，这个环境中源代码被转换为可执行的机器指令。（二进制代码）
第二种是执行环境（运行环境），用于实际执行代码。

详解编译+链接

翻译环境

编译使用的是编译器，链接使用的是链接器。

过程：

1. 组成一个程序的每个源文件都要通过编译过程转换为目标代码。
2. 每个目标文件由链接器捆绑在一起，形成一个单一而完整的可执行程序。
3. 链接器同时也会引入标准C函数库中的所有该程序使用到的函数，而且它可以搜索程序员个人的程序库，将其需要的函数也链接到程序中。

编译还可以分为几个阶段

查看编译期间的每一步发生了什么

在linux环境下

1. 预处理 选项 gcc -E test.c -o test.i

预处理完成之后就停下来，预处理之后产生的结果都放在test.i文件中。

2. 编译 选项 gcc -S test.c

编译完成之后就停下来，结果保存在test.s中。

3. 汇编 gcc -c test.c

汇编完成之后就停下来，结果保存在test.o中。

编译每个阶段的事情

预处理

1. #include 头文件的包含
2. 注释删掉 使用空格来替换注释
3. #define

编译 将test.i翻译为test.s

​ 将c语言代码翻译为汇编代码

	1. 语法分析
	2. 词法分析
	3. 语义分析

汇编

1. 生成可重定位目标文件.o文件，
2. 行成符号表。
3. 汇编指令转换为二进制指令。

链接做的事情

1. 合并段表
2. 符号表的合并和符号表的重定位

运行环境

程序执行的过程：

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

预处理详解

预定义符号

本身就有的符号

__FILE__    //进行编译的源文件，目录及文件名展示%s输出
__LINE__    //文件当前的行号，代码当先所在行   %d输出
__DATE__    //文件被编译的日期，月日年 其中月是英文  %s输出
__TIME__    //文件被编译的时间 正常时分秒  %s输出
__STDC__    //如果编译器遵循ANSI C，这个值为1，如果没有遵循则显示这个值未定义。

使用举例：写日志。

#define 预处理指令

#define、#include都是预处理指令，还有#pragma、#if、#end等

#define定义标识符

#define name stuff
#define MAX 100
#define STR "hehe"

在预编译处理完之后直接将代码中的MAX全部替换为100了。

举例：

#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定义宏

#define机制有一个规定，允许把参数替换到文本中，这种实现通常称为宏(macro)或者定义宏(define macro)。

宏的申明方式：

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

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

举个错误的例子：

#define SQUARE( x ) x * x   //宏定义没有问题，左括号紧跟<name>

这个宏接收一个参数x。在声明之后将SQUARE( 5 );置于程序中，预处理器就会用下面这个表达式替换上面的表达式。5 * 5。

但是，我说过，这个宏存在问题：我们仔细看一个实例

int a = 5;
printf("%d\n",SQUARE( a + 1 ));

正常思路这个结果应该是36.但是他打印的是11。

这是为什么呢？

替换文本时，参数x被替换成a + 1,所以这条语句实际上变成了：

printf ("%d\n",a + 1 * a + 1 );

这样看就很清晰了。替换产生的表达式，并没有按照预想的次序进行求值。

问题解决

在宏定义上加上两个括号，确定优先级就可以了。

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

另一个问题

定义一个新的宏

#define DOUBLE(x) (x)+(x)

定义中使用了括号，感觉应该可以避免之前的问题，但是这个宏还是可能会出现新的问题。

int a = 5;
printf("%d\n",10*DOUBLE(a));

先自己思考结果是什么？

你是不是想的是100，但是实际上是55。

这是为什么呢？

我们将宏替换代码后

printf("%d\n",10*(5)+(5));

这样乘法的运算就先于宏定义的加法了，所以输出为55

问题解决

#define DOUBLE(X) ((x)+(x))

总结：用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免使用宏时参数中的操作符或者邻近操作符之间不可预估的相互作用。（只要记住，宏不是传参，是替换。）

#define替换原则

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

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

注意：

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

#和##

现在有个需求：

void print(int a){
    printf("the value of a is %d\n",a)
}
int main(){
    int a = 10;
    print(a);//这里打印的是 the value of a is 10
    int b = 20;
    print(b);//这里打印的是 the value of a is 20
}

问题就在其中，print(b)的时候打印的还是the value of a is 20。这里我们应该是b，但是他打印的是a。

函数不能做到这样的功能（把参数插入到字符串中。）。但是宏可以。

首先我们要知道，才C语言中存在下面的情况。

int main(){
    printf("hello world");
    printf("hello " "world");
    printf("hel" "lo " "wor" "ld");
}

这三个printf语句都会有hello world的结果。

还有一个技巧：使用#,把一个宏参数变成对应的字符串。

有了这个思路我们就有了一个思路。中间需要插入的部分用宏的方式插入。

#define PRINT(X) printf("the value of " #X " is %d\n",X)
int main(){
    int a = 10;
    PRINT(a);//printf("the value of " "a" " is %d\n",X)
    int b = 20;
    PRINT(b);//printf("the value of " "b" " is %d\n",X)
}

##的作用

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

#define CAT(X, Y) X##Y

int main() {
    int Class12 = 2020;
    // printf("%d\n",Class12);//正常思路的输出
    printf("%d\n", CAT(Class,12));
    //宏定义后printf("%d\n",Class##12);
    //即printf("%d\n",Class12);
}

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

带有副作用的宏参数

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

//举例
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=9 z=9,但是实际输出为x=6 y=10 z=9

这是为什么呢？

我们将预处理后的代码写出

z = ((x++) > (y++) ? (x++) : (y++));

这样，就明白了，我们计算了两次y++。

宏个函数对比

前面写了好几个demo都是将宏当做函数来使用。实现简单的运算。

那么这些东西为什么不直接使用函数来完成呢？

原因：

1. （计算时间）用于调用函数和函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面是优秀的。

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

宏相对于函数的缺点：

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

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

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

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

宏和函数的直接对比

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

命名约定

一般来说函数和宏的使用语法是相似的。所以语言本身没法帮我们区分。所以平时就有一个习惯。

将宏名全部大写、函数名不要全部大写。

#undef

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

//格式
#undef NAME
//如果有一个已经存在的名字需要被重新定义，那么它的旧名字首先要被移除。

命令行定义

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

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;
}

编译指令：

gcc programe.c  -D ARRAY_SIZE=10 

这里的文件名可以放前面也可以放后面。

条件编译

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

比如：

测试性质的代码，删除了可惜，保留下来有比较妨碍事情。所以我们可以选择性的编译。

下面代码将最上面的#define __DEBUG__注释掉和不注释掉结果是不一样的。

#define __DEBUG__

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__
        //如果DEBUG被定义过，那就参与编译，如果没有没定义过就不参与编译
    }
    return 0;
}

在平时写代码的时候，我们总是写printf测试我们的代码。当写在多个地方的时候，注释起来会比较麻烦。写成这样的话，只需要把开头#define __DEBUG__处理一下就可以了。

常见的条件编译指令：

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

使用案例

#define DEBUG 0

int main() {
#if defined(DEBUG)
    printf("#if defined(DEBUG)");
#endif
    //和上面的写法是等价的。
#ifdef DEBUG
    printf("#ifdef DEBUG");
#endif
//如果定义的是编译，没有定义不编译
//那么如果是定义了不编译，没有定义编译的话如下
#if !defined(DEBUG)
    printf("#if !defined(DEBUG)");
#endif
#ifndef DEBUG  //注意：这里加了一个n
    printf("#ifndef DEBUG");
#endif
// 嵌套指令和前面说的差不多。
    return 0;
}

文件包含

我们在引用头文件的时候经常使用#include指令，使另一个文件被编译。就像它实际出现于#include指令的地方一样。

这样的额替换方式很简单：预处理先删除这条指令，并用包含头文件的内容替换。
这样一个源文件被包含10次就编译10次。

头文件被包含的方式：

包含本地文件

#include "filename"

查找策略。先在源文件所在目录下查找，如果该头文件没有找到，编译器就像查找库文件一样在标准位置查找头文件。如果还没有找到就提示编译错误。

标准头文件目录：

Linux环境下

/user/include

我们大部分时候都是在安装路径中可以找到。

包含库文件

#include <filename.h>

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

这样我们就发现，对于库文件也可以使用双引号的形式包含。但是这样做的话，查找的效率就低些，当然这样也不容易区分是本地文件，还是库文件了。

嵌套文件包含

比如在我们开发的时候，文件关系如图所示。

A.h被B.h和C.h调用，B.h和C.h又被D.h调用，这样我们的A.h就被调用了两次，编译的时候就多出了一份A.h这样就造成了文件的重复。

怎么解决这个问题呢？使用条件编译。

方式一：

每个头文件开头写。

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

方式二：

#pragma once   //可以避免头文件的重复引入

其他的预处理指令

#error
#pragma
#line
...
#pragma pack()在结构体部分介绍。

其他的预处理指令