编译和链接+预处理

编译（compile）和链接（link）

在以前我们提到过，C语言是一门编译型的计算机语言，C语言的源代码都是文本文件，文本文件本身无法运行，电脑不能执行C语言代码，计算机能够执行的是二进制指令，那就需要通过编译器翻译和链接器的链接，生成二进制的可执行文件，可执行文件才能执行。

一、翻译环境与运行环境

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

第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令（⼆进制指令）。翻译环境就相当于我们生活中的翻译官

第2种是运行环境，它用于实际执行代码。

二、翻译环境

那翻译环境是怎么将源代码转换为可执行的机器指令的呢？下面我们就展开讲解一下翻译环境所做的事情。

翻译环境是由编译和链接两个大的过程组成的，而编译又可以分解成：预处理（有些书也叫预编译）、编译、汇编三个过程。

源码 (.c) → 预处理 → 编译 → 汇编 → 链接 → 可执行程序，下面详细展开：

⼀个C语⾔的项目中可能有多个 .c 文件⼀起构建，多个 .c 文件如何生成可执行程序呢？

1、多个.c文件单独经过编译器，编译处理生成对应的目标文件。（在Windows环境下的目标文件的后缀是 .obj ，Linux环境下目标文件的后缀是 .o）

2、多个目标文件和链接库⼀起经过链接器处理生成最终的可执行程序。（链接库：是指运行时库(它是支持程序运行的基本函数集合)或者第三方库。）

下面是更详细的路径图：

接下来我们再把编译器展开成3个过程：预处理 → 编译 → 汇编，紧接着还有链接：

1、预处理（预编译）

在预处理阶段，源文件和头文件会被处理成为 .i 为后缀的文件。 在 gcc 环境下观察⼀下，对 test.c 文件预处理后的 .i 文件，命令如下：

指令：gcc -E test.c -o test.i

预处理阶段主要处理那些源文件中 # 开始的预编译指令。比如：#include,#define，处理的规则如下：

1、将所有的 #define 删除，并展开所有的宏定义。
2、处理所有的条件编译指令，如： #if、#ifdef、#elif、#else、#endif 。
3、处理 #include 预编译指令，将包含的头文件的内容插入到该预编译指令的位置。这个过程是递归进行的，也就是说被包含的头文件也可能包含其他文件。
4、删除所有的注释
5、添加行号和文件名标识，方便后续编译器生成调试信息等。
6、或保留所有的 #pragma 的编译器指令，编译器后续会使用。

经过预处理后的 .i 文件中不再包含宏定义，因为宏已经被展开。并且包含的头文件都被插入到.i文件中。所以当我们无法知道宏定义或者头文件是否包含正确的时候，可以查看预处理后的 .i 文件来确认。

2、编译

编译过程就是将预处理后的文件进行一系列的：词法分析、语法分析、语义分析及优化，生成相应的
汇编代码文件。

编译过程的命令如下：

指令：gcc -S test.i -o test.s

我们用下面这一行代码来简单聊一下 词法分析、语法分析、语义分析及优化：

array[index] = (index+4)*(2+6);

1）词法分析

将源代码程序被输入扫描器，扫描器的任务就是简单的进行词法分析，把代码中的字符分割成一系列的记号（关键字 标识符 常量 运算符 分隔符等）。

上面程序进行词法分析后得到了16个记号：

2）语法分析

接下来语法分析器，将对扫描产生的记号进行语法分析，从而产生语法树。这些语法树是以表达式为节点的树。

3）语法分析

由语义分析器来完成语义分析，即对表达式的语法层⾯分析。编译器所能做的分析是语义的静态分析。静态语义分析通常包括声明和类型的匹配，类型的转换等。这个阶段会报告错误的语法信息。

咱们在这里就是简单说一下，真正的编译阶段是非常complex的。

3、汇编

汇编就是：汇编器是将汇编代码转变成机器可执行的指令，每⼀个汇编语句几乎都对应⼀条机器指令。就是根据汇编指令和机器指令的对照表一一的进行翻译，也不做指令优化。

汇编的命令如下：

gcc -c test.s -o test.o

4、链接

链接是⼀个复杂的过程，链接的时候需要把⼀堆文件链接在一起才生成可执行程序。

链接过程主要包括：地址和空间分配，符号决议和重定位等这些步骤。

链接解决的是一个项目中多文件、多模块之间互相调用的问题。

链接器其实就像一个组装工一样，将 .obj文件就是一个个散落的零件，链接器把所有零件、标准库配件拼一起，拧紧地址螺丝，变成可以运行的可执行程序。

上面我们非常简洁的讲解了一个C的程序是如何编译和链接，到最终生成可执行程序的过程，其实很多内部的细节无法展开讲解，感兴趣的话，可以去看一看《程序员的自我修养》这本书，会很有帮助。

三、运行环境

程序运行时到底做了些什么呢？下面也简单聊一下：

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

预处理详解

一、预定义符号

C语言设置了⼀些预定义符号，可以直接使用，预定义符号也是在预处理期间处理的。

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

我可以打印出来看一看：

二、#define定义常量

基本语法： #define name stuff

一些栗子：

#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定义标识符的时候，要不要在最后加上 ; 呢？这里建议是不要加上 ; ，这样容易导致问题。看下面代码：

程序会直接报错，因为在编译的预处理过程后，代码会变成下面这样：不符合语法规则

printf("%d\n",1000;):

三、#define定义宏

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

下面是宏的申明方式：

#define name( parament-list ) stuff 其中的 parament-list 是⼀个由逗号隔开的符号表（就是参数），它们可能出现在stuff中 参数可以有一个，可以有多个，也可以没有

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

下面是1个栗子：

看得到，很完美的输出了我们想要的结果，可是在这其中却有一个问题存在，当我们将参数写成 a + 1 时：

哦豁，竟然是11，其实细想一下，预处理后的结果是：

int ret = a + 1 * a + 1; 5 + 1 * 5 + 1 = 11

这样写出来就比较清晰了，由替换产生的表达式并没有按照预想的次序进行求值。

解决的话也很简单，在宏定义上面加两个括号就ok了：

#define SQUARE(x) (x)*(x) int ret = (a + 1) * (a + 1); (5 + 1) * (5 + 1) = 36

但并不是所有都要这样加括号哈，看下面的代码：

按照我们预想的结果应该是100，怎么会是55呢？

#define DOUBLE(x) (x)+(x) 10 * (5) + (5) = 55

替换之后，由于乘法运算先于宏定义的加法，所以是55

解决方案是在表达式两边加上一对括号就可以了：

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

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

四、带有副最用的宏参数

先来解释一下副作用是什么：

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

第二种在进行赋值的时候会改变本身的值

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

正常传递整型参数时，结果与我们预想的一样，可如果我按照下面这种方式传参呢？

int m = MAX(a++, b++);

如果不过脑子的话，随便一想，后置++，先传递，后+1，m还是等于5，看起来没毛病啊。可是，m真的是5吗？那a,b又是多少呢？我们写一下预处理器处理之后的结果是什么：

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

明显，带有副作用的参数出现了，结果与我们预想的是不一样的：

所以，宏参数尽量不要使用自增、自减这类带副作用的表达式，并且避免同一个变量在宏里被多次运算，引发逻辑错误。

五、宏替换的规则

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

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

#define M 10 printf("M = %d\n"，M); //""里面的M不会被替换

六、宏与函数与的对比

宏：预处理阶段纯文本替换，无语法检查，不产生函数调用
函数：编译阶段编译成代码，运行时调用执行，有语法 / 类型检查

宏通常被应用于执行简单的运算。

比如在两个数中找出较大的⼀个时，写成宏的话，会有优势⼀些：

#define MAX(a, b) ((a)>(b)?(a):(b))

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

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

但确实宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到，栗子：我们想用 malloc 开辟10个整型的空间，但开辟空间的这句代码比较长，我们可以自己写一个 Malloc宏：

#include <stdio.h> #include <stdlib.h> #define Malloc(n,type) (type*)malloc(n*sizeof(type))//定义一个Malloc宏 int main() { int* p1 = (int*)malloc(10 * sizeof(int));//正常开辟 int* p2 = Malloc(10, int); return 0; }

这个宏与函数相比最大的优势可以传递参数，略胜一筹。

宏与函数可以说是各有千秋，下面来对比一下：

七、#undef

宏可以被定义，那可不可以被移除呢？答案是肯定的，需要用到 #undef 这条指令，演示一下：

可以看到执行 #undef 后，直接报错了，说明 MAX 已经不再是宏

八、#与##

1、#运算符

# 运算符将宏的一个参数转换为字符串字面量。它仅允许出现在带参数的宏的替换列表中。因此 # 运算符所执行的操作可以理解为”字符串化“。这句话听着着实有点抽象了，那就举一个栗子吧：
当我们有⼀个变量 int a = 10; 的时候，我们想打印出： the value of a is 10。我可以这样写：

#include <stdio.h> int main() { int a = 10; printf("the value of a is %d\n", a); return 0; }

当我更多整型变量，甚至浮点型变量时，我都想打印这句话，那我是不是可以定义一个宏来完成这个任务，为什么不是函数呢，因为类型不同，函数只能传递一个类型，宏的参数就是变量的名字与打印的格式就OK：

由于 n 是字符串里的内容，所以我们想要的名字 a 并未改变，这时就要用到 #运算符了：

2、##运算符

## 可以把位于它两边的符号合成⼀个符号，它允许宏定义从分离的文本片段创建标识符。 ## 被称为记号粘合这样的连接必须产⽣⼀个合法的标识符。否则其结果就是未定义的。依旧抽象哈，继续举例子吧：
当写⼀个函数求2个数的较大值的时候，不同的数据类型就得写不同的函数。

int int_max(int x, int y) { return x > y ? x : y; } float float_max(float x, float y) { return x > y ? x : y; }

这样写过于繁琐了，那有没有办法可以批量生产呢？这时我们又想到了宏，用宏可以怎么写呢，下面是代码：

#include <stdio.h> #define FUNCTION_MAX(type) \ type type##_max(type x,type y)\ {\ return x>y?x:y;\ } //定义函数 FUNCTION_MAX(int); FUNCTION_MAX(float); int main() { int r1 = int_max(4, 5); printf("%d\n", r1); float r2 = float_max(2.5f, 3.9f); printf("%f\n", r2); return 0; }

那这里就会有疑问了，如果我不写 ## ，会怎么样呢？直接写 type_max 的话，会将这个符号看为一个整体，不会单独析出 type 来替换我们所写的 type，如果括号内是 int 的话替换后的是这样的：int type_max(int x,int y)，所有生成的函数名都叫 type_max。因此要用 ##运算符。

九、命令行定义

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

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

我们并未定义 SZ 的大小，就可以在命令行中定义 SZ 的大小。

//linux 环境演⽰ gcc -D SZ=10 test.c //这就等价于在代码里面写：#define SZ 10

十、条件编译

在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃是很方便的。因为我们有条件编译指令。条件编译就是预处理阶段根据宏是否定义，选择性编译部分代码，不满足条件的代码直接丢弃，不参与编译。

常用的条件编译指令有：

1、if 常量表达式

#if 常量表达式 //... #endif //常量表达式由预处理器求值。

根据 #if 后面条件的真假，来判断是否执行 #endif 前面的语句。

这条条件编译指令还可以用来进行注释：

可见代码都透明了，虽然存在，但进行编译的时候这段代码是不参与的

2、多个分支的条件编译

#if 常量表达式 //... #elif 常量表达式 //... #else //... #endif

3、判断是否被定义

#ifdef symbol（或者#if defined(symbol)） #ifndef symbol（或者#if !defined(symbol)）

4、嵌套指令

#if defined(DE1) #ifdef OPTION1 语句 #endif #ifdef OPTION2 语句 #endif #elif defined(DE2) #ifdef OPTION2 语句 #endif #endif

十二、头文件

1、头文件被包含的方式

这两种方式是：双引号形式与尖括号形式，这两种方式是有区别的，在我们的认知中就是双引号包含的是自己写的 .h 头文件，尖括号包含的是标准库中的头文件，那为什么是这样的呢，其实是两者的查找策略有所不同。下面来谈一谈

1）本地文件包含（双引号）

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

2）库文件包含（尖括号）

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

2、嵌套文件包含

我们已经知道， #include 指令可以使另外⼀个文件被编译。就像它实际出现于 #include 指令的地方一样。 这种替换的方式很简单：预处理器先删除这条指令，并用包含文件的内容替换。
若⼀个头文件被包含10次，那就实际被编译10次，如果重复包含，对编译的压力就比较大。就像下面的代码：

test.h： void test(); struct Stu { int id; char name[20]; }; test.c #include "test.h" #include "test.h" #include "test.h" #include "test.h" #include "test.h" int main() { return 0; }

test.c 文件中将 test.h 包含5次，那么 test.h 文件的内容将会被拷贝5份在 test.c 中。如果 test.h 文件比较大，这样预处理后代码量会剧增。如果工程比较大，有公共使用的头文件，被大家都能使用，如果不做任何的处理，就很容易出现这种在同一个包含好多相同的头文件的情况，那么后果真的不堪设想。那要怎么解决头文件被重复引入的问题呢？答案就是：条件编译。像下面这样写：

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

原理就是第一次包含定义宏，再次包含时条件不成立，直接跳过内容，这样只会有一份头文件。

还有一种写法：

#pragma once

这条指令的作用就是头文件保护，避免同一个 .h 被多次 #include 导致报错，与条件编译效果是一样的。这条指令非常简洁，但这条指令不是C标准的中的指令，是一些编译器特有的。

万千个体的命运，不过是万古长夜里一粒因风而起、不知归处的微尘。

一切欣喜与苦涩，皆是命运偶然落笔的结果。

也正因如此，通往幸福的道路上，注定充满变数。

需要耐心与毅力、需要颠簸与磋磨，也需要一些机缘巧合。

只是偶尔，人们拼尽全力、几经周折，也难逃命运赋予的因果。

于是，在我眼里，一切感知、情绪与爱恨嗔痴，都不过是命运湍流里，不起眼的浪花与涟漪。

我洞悉了命运的宏大与无情，所以对周遭的流转，总持有一种近乎冷漠的平静。

我习惯将所有的挑战与酸涩独自咽下，从不因世道艰难，便心安理得地把苦痛当作博取同情的筹码。

我只愿以足够的努力、隐忍与虔诚，换取命运的一次回眸与垂青。