编译和链接+预处理详解

目录

1.翻译环境和运行环境

2.翻译环境

2.1预处理（预编译）

2.2编译

词法分析

语法分析

语义分析

2.3 汇编

2.4 链接

3.运行环境

预处理详解

1.预定义符号

2.#define定义常量

3.#define定义宏

4.带有副作用的宏参数

5.宏替换规则

6.宏函数的对比

7.#和##

#运算符

##运算符

8.命名约定

9.#undef

10.命令行定义(Linux)

11.条件编译

12.头文件的包含

本地文件包含

库文件包含

嵌套文件包含

---

1.翻译环境和运行环境

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

1.翻译环境：源代码被转换为可执行的机器指令（二进制指令）

​2.运行环境：实际执行代码

2.翻译环境

翻译环境是由编译和链接两个过程组成的，而其中的编译过程可以分解成：预处理（也称预编译）、编译、汇编三个过程

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

1️⃣ 多个.c文件单独经过编译器编译处理生成对应的目标文件（目标文件也是二进制文件） 2️⃣ 在Windows环境下的目标文件的后缀是 .obj ，Linux环境下目标文件的后缀是 .o 3️⃣ 多个目标文件和链接库⼀起经过链接器处理生成最终的可执行程序。 4️⃣ 链接库是指运行时库(它是支持程序运行的基本函数集合)或者第三方库

如果再把编译器展开成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

对下面代码进行编译的时候，会怎么做呢？假设有下面的代码

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

词法分析

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

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

语法分析

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

语义分析

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

 

2.3 汇编

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

汇编的命令如下：

gcc -c test.s -o test.o

2.4 链接

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

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

比如：

在一个C的项目中有两个.c文件（test.c和add.c）

test.c

#include <stdio.h>
//test.c
//声明外部函数
extern int Add(int x,int y);
//声明外部的全局变量
extern int g_val;

int main()
{
  	int a = 10;
  	int b = 20;
  	int sum = Add(a,b);
  	printf("%d\n",sum);
  	return 0;
}

 add.c

int g_val = 2022;
int Add(int x, int y){
  	return x+y;
}

我们已经知道，每个源文件都是单独经过编译器处理生成对应的目标文件。

test.c经过编译器处理生成 test.o

add.c经过编译器处理生成 add.o

我们在 test.c的文件中使用了add.c文件中的Add函数和g_val变量。

我们在test.c的文件中每一次使用Add函数和g_val的时候必须确切的知道Add和g_val的地址，但是由于每个文件是单独编译的，在编译器编译test.c的时候并不知道Add函数和g_val变量的地址，所以暂时把调用Add的指令和目标地址和g_val的地址搁置。等待最后链接的时候由链接器根据引用的符号Add在其他模块中查找Add函数的地址，然后将test.c中所有引用到Add的指令重新修正，让他们的目标地址为真正的Add函数的地址，对于全局变量g_val也是类似的方法来修正地址。这个地址修正的过程也被叫做：重定位

前面我们非常简洁的讲解了一个C的程序是如何编译和链接，到最终生成可执行程序的过程，其实很多内部的细节无法展开讲解。比如：目标文件的格式elf，链接底层实现中的空间与地址的分配，符号解析和重定位等，如果有兴趣可以看《程序员的自我修养》一书来详细了解。

3.运行环境

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

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

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

4. 4.终止程序。正常终止main函数或者意外终止main函数

预处理详解

1.预定义符号

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

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

举个例子

#include <stdio.h>

int main(int argc, const char * argv[]) {
    printf("文件位置:%s\n当前代码所在行数：%d\n代码编译日期：%s\n代码编译时间：%s\n", __FILE__, __LINE__, __DATE__, __TIME__);

    return 0;
}
文件位置:/Users/nanyi/Desktop/代码/c_bit/预处理/预处理/main.c
当前代码所在行数：11
代码编译日期：Jul  6 2024
代码编译时间：15:26:02

2.#define定义常量

基本语法

#define name stuff

举个例子：

//#define定义常量
#define MAX 1000 //定义一个MAX常量，其值为1000
#define RES register //为register关键字定义一个更简短的名字
#define cycle_forever for(;;) //为死循环的实现定义一个只管的符号
#define CASE break;case //在case语句后自动加上break，使用CASE:时，将替换为break;case:
//如果定义的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后边只能有一条语句。这里会出现语法错误

3.#define定义宏

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

下面是宏的申明方式：

#define name( parament-list ) stuff

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

注意：

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

举例：

#define SQUARE(x) x*x

这个宏接受一个参数x，如果在上述声明之后，你把SQURAE(9)；置于程序中，预处理就会用下面这个表达式替换上面的表达式：9*9

#define SQUARE(x) x*x
#include <stdio.h>

int main(int argc, const char * argv[]) {
    int ret = SQUARE(9);
    printf("%d\n",ret);
    return 0;
}
输出结果：
81

警告：这个宏存在一个问题

比如：

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)

这样预处理之后就产生了预期的效果：

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

这里还有一个宏定义：

#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 ) )

提示：

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

4.带有副作用的宏参数

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

例如：

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

MAX宏可以证明具有副作用的参数所引起的问题。

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
...
x = 5;
y = 8;
z = MAX(x++, y++);
printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？

//也就是
  z = ( (x++) > (y++) ? (x++) : (y++));
//所以输出结果是：x = 6 y = 10 z = 9

5.宏替换规则

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

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

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

3. 3.最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程

注意：

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

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

6.宏函数的对比

宏函数被应用于执行简单的运算。

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

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

上面两种方式比较中宏的优势：

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

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

和函数相比宏的劣势：

1. 1.每次使用宏的时候，宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度

1. 2.宏没法调试，因为在预编译过程中已经发生了替换

1. 3.宏由于类型无关，也就不够严谨

1. 4.宏可能会带来运算符优先级的问题，导致程序容易出现错误

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

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

宏和函数的对比

7.#和##

#运算符

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

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

当我们有一个变量 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就是转换为“a”，的一个字符串
//代码就会被预处理为：
printf("the value of ""a" " is %d", a);
//运行代码就能在屏幕上打印：
the value of a is 10

 

##运算符

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

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

这里我们想想，写一个函数求2个数的较大值的时候，不同的数据类型就得写不同的函数

比如：

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

但这样写起来太繁琐了，现在我们这样写代码试试：

//宏定义
#define GENERIC_MAX(type) \
type type##_max(type x, type y)\
{ \
return (x>y?x:y); \
}

使用宏，定义不同函数

GENERIC_MAX(int) // 替换到宏体内后int##_max 生成了新的符号 int_max做函数名
GENERIC_MAX(float) // 替换到宏体内后float##_max 生产了新的符号 float_max做函数名

int main()
{
		//调用函数
		int m = int_max(2, 3);
		printf("%d\n", m);
		float fm = float_max(3.5f, 4.5f);
		printf("%f\n", fm);
  
		return 0;
}
输出：
  3
  4.500000

在实际开发过程中##使用的很少，很难取出非常贴切的例子。

8.命名约定

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

那我们平时的一个习惯时：

把宏名全部大写

函数名不要全部大写

9.#undef

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

#undef NAME
//如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除

10.命令行定义(Linux)

许多C的编译器提供了⼀种能力，允许在命令行中定义符号。用于启动编译过程

例如：当我们根据同一个源文件要编译出一个程序的不同版本的时候，这个特性有点用处。（假定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器内存大，我们需要一个数组能够大）

#include <stdio.h>
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 -D ARRAY_SIZE=10 programe.c
//-D ARRAY_SIZE=10为ARRAY_SIZE指定大小

11.条件编译

所谓条件编译，即满足指定条件时进行编译，不满足时不编译

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

常见的条件编译指令

1.
#if  常量表达式
        //语句
#endif
//常量表达式由预处理器求值，并且不能使用变量，因为变量在预处理过程中并没有具体值
如：
#define __DEBUG__ 1
#if __DEBUG__ //如果DEBUG值为非0值，则编译语句，为0则不编译
        //语句
#endif
 
#if 1==2 //1==2为假，不编译语句
        //语句
#endif
 
2.多个分⽀的条件编译（只会走其中一个条件，与if-else-if逻辑相同）
#if 常量表达式
        //语句
#elif 常量表达式
        //语句
#else
        //语句
#endif
 
3.判断是否被定义
#if defined(symbol) //定义了symbol就编译，否则不编译
        //语句
#endif
 
#ifdef symbol //定义了symbol就编译，否则不编译
        //语句
#endif
 
#if !defined(symbol) //未定义symbol就编译，否则不编译
        //语句
#endif 
 
#ifndef symbol //未定义symbol就编译，否则不编译
        //语句
#endif
 
4.嵌套指令
#if defined(OS_UNIX)//定义了OS_UNIX则编译if内的内容
        #ifdef OPTION1 //定义了OPTION1，则编译
                unix_version_option1();
        #endif
        #ifdef OPTION2 //定义了OPTION2，则编译
                unix_version_option2();
        #endif
#elif defined(OS_MSDOS)//定义了OS_UNIX则编译elif内的内容
        #ifdef OPTION2 //定义了OPTION2，则编译
                msdos_version_option2();
        #endif
#endif

12.头文件的包含

本地文件包含

#include "filename"

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

Linux环境的标准头文件的路径

/usr/include

VS环境的标准头文件的路径：

C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
//这是vs2013的默认路径

注意按照自己的安装路径去找

库文件包含

#include <filename.h>

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

注意：

对于库文件也可以使用""的形式，但是这样做查找的效率就低些，因为库文件一般都不在源文件所在目录，但是有需要再原文件所在目录进行查找，浪费一定的时间，并且这样也不容易区分是库文件还是本地文件

嵌套文件包含

在使用#include指令时，预处理器先删除#include，并用包含文件的内容替换。如果一个头文件被包含10次，那就实际被编译10次，如果重复包含，对编译的压力就比较大

可以使用条件编译防止头文件被多次包含

//头文件中的#ifndef/#define/#endif用于防止头文件被重复引入
#ifndef __TEST_H__//在第二次之后，查找发现文件中定义了__TEST_H__，则不进行编译后面的语句
#define __TEST_H__//在原来的头文件中第一次未定义__TEST_H__，则会编译本条语句以及头文件的内容
//头⽂件的内容 
#endif   //__TEST_H__
 
//或者
#pragma once
//就可以避免头文件的重复引入。