C语言编译与链接详解：从预处理到运行环境

C语言编译与链接详解：从预处理到运行环境

引用

CSDN

1.

https://blog.csdn.net/2302_81486993/article/details/140912839

本文详细介绍了C语言的编译与链接过程，重点讲解了预处理阶段的各个方面，包括宏定义、条件编译、头文件包含等。对于C语言开发者来说，理解这些内容有助于深入掌握语言的底层机制。

前言

本篇博客为大家介绍C语言中最后的语法内容——预处理，同时还要介绍编译与链接的内容，这为大家理解代码的底层逻辑将会有所帮助，下面我们来进行正文介绍。

1. 翻译环境和运行环境

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

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

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

2. 翻译环境

那翻译环境是怎么将源代码转换为可执行的机器指令的呢？这里我们就得展开讲解一下翻译环境所 做的事情。 其实翻译环境是由编译和链接两个大的过程组成的，而编译又可以分解成：预处理（有些书也叫预编译）、编译、汇编三个过程。

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

• 多个.c文件单独经过编译器，编译处理生成对应的目标文件。
• 注：在Windows环境下的目标文件的后缀是 .obj ，Linux环境下目标文件的后缀是 .o
• 多个目标文件和链接库一起经过链接器处理生成最终的可执行程序。
• 链接库是指运行时库(它是支持程序运行的基本函数集合)或者第三方库。
  如果再把编译器展开成3个过程，那就变成了下面的过程：

2.1 预处理

在预处理阶段，源文件和头文件会被处理成为.i为后缀的文件。

在 gcc 环境下想观察一下，对 test.c 文件预处理后的.i文件，命令如下：

gcc -E test.c -o test.i

预处理阶段主要处理那些源文件中#开始的预编译指令。

比如：#include,#define，处理的规则如下：

• 将所有的#define 删除，并展开所有的宏定义。
• 处理所有的条件编译指令，如： #if、#ifdef、#elif、#else、#endif 。
• 处理#include预编译指令，将包含的头文件的内容插入到该预编译指令的位置。这个过程是递归进行的，也就是说被包含的头文件也可能包含其他文件。
• 删除所有的注释
• 添加行号和文件名标识，方便后续编译器生成调试信息等。
• 或保留所有的#pragma的编译器指令，编译器后续会使用。经过预处理后的.i文件中不再包含宏定义，因为宏已经被展开。并且包含的头文件都被插入到.i文件中。所以当我们无法知道宏定义或者头文件是否包含正确的时候，可以查看预处理后的.i文件来确认 。

2.2 编译

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

gcc -S test.i -o test.s

2.3 汇编

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

汇编的命令如下：

gcc -c test.s -o test.o

2.4 链接

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

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

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

3. 运行环境

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

4. 预定义符号

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

5. #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;

如果是加了分号的情况，等替换后，if和else之间就是2条语句，而没有大括号的时候，if后边只能有一条语句。这里会出现语法错误。

6. #define定义宏

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

#define name( parament-list ) stuff  

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

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

下面来举个例子：我们来进行平方运算

#define SQUARE( x ) x * x
#include<stdio.h>
int main()
{
    int a = 5;
    int ret = SQUARE(a);
    printf("%d", ret);
    return 0;
}  

这里大家可以看到，我们实现了平方的运算，但是大家注意这个宏定义，它一定正确吗？

咱们来看下面的例子：

#define SQUARE( x ) x * x
#include<stdio.h>
int main()
{
    int a = 5;
    int ret = SQUARE(a+1);
    printf("%d", ret);
    return 0;
}  

大家看到，我将参数改成a+1，那么我们应该得到什么结果呢？大部分人心里肯定有了答案，36呗；然而事实非也，大家请看下面运行结果：

大家看到，结果是11，并非36，那这是为何呢？

#define SQUARE( x ) x * x//a+1*a+1
#include<stdio.h>
int main()
{
    int a = 5;
    int ret = SQUARE(a+1);
    printf("%d", ret);
    return 0;
}  

这里大家要注意。宏的参数不会计算，直接进行替换，所以我们得不到36。

那么我们要怎么改善一下呢？大家请看

我们加上括号，就可以解决这个问题。说到这里，建议大家在进行宏定义时，所以用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用。

7. 带有副作用的宏参数

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

这里给大家举个例子，来看一下宏参数存在的副作用；

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
#include<stdio.h>
int main()
{
    int a = 3;
    int b = 5;
    int ret = MAX(a++, b++);
    printf("%d\n", ret);
    printf("%d\n", a);
    printf("%d\n", b);
    return 0;
}  

这段代码大家可以先看一下，试着算一下结果。

大家可以看到，这里我们本来是相求出两个数中的较大值，我们想要的结果应该是5，但是输出结果为6，所以这就是宏参数的副作用。

8. 宏替换规则

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

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

注意：

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

9. 宏与函数的对比

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

比如在两个数中找出较大的一个时，写成下面的宏，更有优势一些。

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

那为什么不用函数来完成这个任务？

原因有二：

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

和函数相比宏的劣势：

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

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

10. #和##

10.1 #运算符

#运算符将宏的一个参数转换为字符串字面量。它仅允许出现在带参数的宏的替换列表中。

#运算符所执行的操作可以理解为”字符串化“。

当我们有一个变量 int a = 10; 的时候，我们想打印出： the value of a is 10 。

就可以写：

#define PRINT(n) printf("the value of "#n " is %d", n);  

当我们按照下面的方式调用的时候： PRINT(a);

当我们把a替换到宏的体内时，就出现了#a，而#a就是转换为：

printf("the value of ""a" " is %d", a);

10.2 ##运算符

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

被称为记号粘合 这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。

##运算符在实际情况中很少用到，这里大家了解即可。

11. 命名约定

一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者。

那我们平时的一个习惯是： 把宏名全部大写；函数名不要全部大写。

12. #undef

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

13. 条件编译

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

因为我们有条件编译指令。 比如说： 调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。

#include <stdio.h>
#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__
 }
 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  

14. 头文件的包含

14.1 头文件被包含的方式

14.1.1 本地文件包含

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

14.1.2 库文件包含

查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。 这样是不是可以说，对于库文件也可以使用 “” 的形式包含？ 答案是肯定的，可以；但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。

14.2 嵌套文件包含

我们已经知道， #include 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方一样。

这种替换的方式很简单：预处理器先删除这条指令，并用包含文件的内容替换。 一个头文件被包含10次，那就实际被编译10次，如果重复包含，对编译的压力就比较大。

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

如果直接这样写，test.c文件中将test.h包含5次，那么test.h文件的内容将会被拷贝5份在test.c中。 如果test.h文件比较大，这样预处理后代码量会剧增。如果工程比较大，有公共使用的头文件，被大家都能使用，又不做任何的处理，那么后果真的不堪设想。 如何解决头文件被重复引的问题？答案：条件编译。

每个头文件的开头写：

或者：

以上两种方式的任意一种，都可以避免头文件的重复引用。

15. 总结

本篇博客到这里就结束了，主要为大家介绍了C语言中编译与链接的大概过程，其中重点为大家介绍了预处理的详细内容，这也是C语言最后一个语法知识，希望大家可以认真理解，最后，希望本篇文章可以为大家带来帮助，感谢阅读！