程序环境和预处理 - 带你了解底层的的编译原理

秒速五厘米 2023-10-13 20:44 50阅读 0赞

> **作者主页：**[paper jie的博客][paper jie]
> 
> **本文作者：**大家好，我是paper jie，感谢你阅读本文，欢迎一建三连哦。
> 
> **本文录入于**《系统解析C语言》专栏，本专栏是针对于大学生，编程小白精心打造的。笔者用重金(时间和精力)打造，将基础知识一网打尽，希望可以帮到读者们哦。
> 
> **其他专栏：**《算法详解》《C语言》《C语言-语法篇》等
> 
> **内容分享：**本期将对程序环境和预处理进行详细的解读~

**目录**

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

编译与链接

翻译环境

编译的几个阶段

运行环境

预处理

预定义符号

\#define

\#define定义标识符

\#define定义宏

\#define的替换规则

带副作用的宏参数

宏和函数对比

命名约定

\#undef

命令行定义

条件编译

文件包含

头文件被包含的方式

嵌套文件包含

--------------------

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

在标准 C中的任何一种实现中，都有两个不同的环境，一个是**翻译环境**，在这种情况下源代码被转换为可执行的机器指令。另一个是**执行环境**，它用于实际执行代码。

因为我们编写的代码是文本指令，而计算机只能识别二进制指令，翻译环境就是将我们的代码文本转化为二进制指令（这时它就是可执行程序）。执行环境就是运行二进制的指令。

# 编译与链接 #

## 翻译环境 ##

组成一个程序的多个源文件通过编译过程分别将它们转化为目标代码。这时每一个代码都被链接器链接起来，形成了一个单一而完整的可执行程序。链接器同时也会引入标准库中任何被这个程序所用到的函数，它还可以搜索程序员个人的程序库，将其需要的函数也链接到程序中。

![ff8d4552582c4d909a5e97b10c339e5b.png][]

## 编译的几个阶段 ##

![bc14d395fb364ca596816bb0adfa849f.png][]

**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. 程序必须载入内存中，在有操作系统的环境中：一般都由操作系统来完成。在独立的环境中，程序的载入必须由手工安排。但也可能是通过可执行代码置入只读内存中完成。**

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

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

**4. 终止程序。 正常终止main函数；也有可能是意外终止。**

# 预处理 #

## 预定义符号 ##

> **\_\_FILE\_\_ //进行编译的源文件** 
> 
> **\_\_LINE\_\_ //文件当前的行号** 
> 
> **\_\_DATE\_\_ //文件被编译的日期** 
> 
> **\_\_TIME\_\_ //文件被编译的时间** 
> 
> **\_\_STDC\_\_ //如果编译器遵循ANSI C，其值为1，否则未定义**

这些预定义符号都是C语言内置的。

## \#define ##

### \#define定义标识符 ###

> **语法：** 
> 
> **\#define 名字 内容**

**栗子：**

#define MAX 1000
    #define reg register          //为 register这个关键字，创建一个简短的名字
    #define do_forever for(;;)     //用更形象的符号来替换一种实现
    #define CASE break;case        //在写case语句的时候自动把 break写上。

**注意：  
在define定义标识符的时候，最后不能加上；这样会出问题的。**

**栗子：**

if(condition)
     max = MAX;
    else
     max = 0;

这样子就会出现语法错误的。

### \#define定义宏 ###

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

宏（define macro）。

下面是宏的申明方式：

\#define name( 参数  ) 定义的内容

**注意：**

参数列表的左括号必须与name紧邻。 如果两者之间有任何空白存在，参数列表就会被解释为右边的内容。

**栗子：**

> \#define SQUARE( x ) x \* x

这个宏接收一个参数 x， 果在上述声明之后，你把

> SQUARE (  5  );

置于程序中，预处理器就会用下面这个表达式替换上面的表达式：

> 5 \* 5

**注意：**

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

解释：

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

这个代码不仔细看会以为它将打印36的值。但是它只会打印11.

因为：

替换文本时，参数被换成了5+1，这条语句实际上则是：

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

这里我们就可以发现替换的表达式并没有按我们想要的结果来计算。

解决方法就是在宏定义上加上两个括号就可以了：

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

需注意的是括号的添加是根据你希望达到的预期来设置的，在不影响计算顺序下，宁可多不可少。

### \#define的替换规则 ###

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

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

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

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

**注意：**

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

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

### 带副作用的宏参数 ###

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

**栗子：**

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

和我们想象的完全不一样，这就是弊端。

### 宏和函数对比 ###

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

但是为什么不用函数来完成简单的计算呢

**原因：**

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

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

**宏的缺点：**

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

2. 宏是没法调试的

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

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

**宏和函数的对比表：**

<table style="width:660px;"> 
 <tbody> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;"><strong>属 </strong></span> 
    </div> 
    <div> 
     <span style="color:#333333;"><strong>性</strong></span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;"><strong>#define</strong></span> 
     <span style="color:#333333;"><strong>定义宏 </strong></span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;"><strong>函数</strong></span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">代 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">码 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">长 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">度 </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">每次使用时，宏代码都会被插入到程序中。除了非常 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">小的宏之外，程序的长度会大幅度增长</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">函数代码只出现于一个地方；每 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">次使用这个函数时，都调用那个 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">地方的同一份代码 </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">执 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">行 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">速 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">度 </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">更快</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">存在函数的调用和返回的额外开 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">销，所以相对慢一些 </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">操 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">作 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">符 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">优 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">先 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">级</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">宏参数的求值是在所有周围表达式的上下文环境里， </span> 
    </div> 
    <div> 
     <span style="color:#333333;">除非加上括号，否则邻近操作符的优先级可能会产生 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">不可预料的后果，所以建议宏在书写的时候多些括 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">号。</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">函数参数只在函数调用的时候求 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">值一次，它的结果值传递给函 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">数。表达式的求值结果更容易预测</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">带 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">有 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">副 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">作 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">用 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">的 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">参 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">数</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">参数可能被替换到宏体中的多个位置，所以带有副作 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">用的参数求值可能会产生不可预料的结果。 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">函</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">函数参数只在传参的时候求值一 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">次，结果更容易控制。</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">参 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">数 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">类 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">型</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">宏的参数与类型无关，只要对参数的操作是合法的， </span> 
    </div> 
    <div> 
     <span style="color:#333333;">它就可以使用于任何参数类型。</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">函数的参数是与类型有关的，如 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">果参数的类型不同，就需要不同 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">的函数，即使他们执行的任务是 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">相同的。</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">调 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">试</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">宏是不方便调试的</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">函数是可以逐语句调试的</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">递 </span> 
    </div> 
    <div> 
     <span style="color:#333333;">归</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">宏是不能递归的</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">函数是可以递归的</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

### 命名约定 ###

一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者。 那我们平时的一个习惯是：

**把宏名全部大写**

**函数名不要全部大写**

## \#undef ##

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

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

## 命令行定义 ##

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

编译指令：

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

## 条件编译 ##

在编译一个程序的时候我们如果要将一条语句编译或者放弃是很方便的，因为我们可以编译条件。

**栗子：**

#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

## 文件包含 ##

### 头文件被包含的方式 ###

**本地文件包含**

#include "源文件名"

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

**库文件包含**

#include <头文件名字>

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

### 嵌套文件包含 ###

![6f711ecb4a124f76b2cf838060c7cc95.png][]

**在这里我们可以知道：**

comm.h 和 comm.c 是公共模块。

test1.h 和 test1.c 使用了公共模块。

test2.h 和 test2.c 使用了公共模块。

test.h 和 test.c 使用了 test1 模块和 test2 模块。

这样最终程序中就会出现两份 comm.h 的内容。这样就造成了文件内容的重复。

**解决办法：**

条件编译

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

#pragma once

加上它们就解决问题了

--------------------

[paper jie]: https://blog.csdn.net/paperjie?type=blog
[ff8d4552582c4d909a5e97b10c339e5b.png]: https://img-blog.csdnimg.cn/ff8d4552582c4d909a5e97b10c339e5b.png
[bc14d395fb364ca596816bb0adfa849f.png]: https://img-blog.csdnimg.cn/bc14d395fb364ca596816bb0adfa849f.png
[6f711ecb4a124f76b2cf838060c7cc95.png]: https://img-blog.csdnimg.cn/6f711ecb4a124f76b2cf838060c7cc95.png