【C语言】预处理

Love The Way You Lie 2024-03-17 21:32 35阅读 0赞

#### 文章目录 ####

*  一、程序环境
 *   *  1、程序的翻译环境和执行环境
     *  2、编译+链接
     *   *  1.翻译环境
         *  2.翻译阶段
         *  3.运行环境
 *  二、预处理
 *   *  1、预定义符号
     *  2、\#define
     *   *  1.\#define定义标识符
         *  2.\#define定义宏
         *  3.\#define替换规则
         *  4.\#和\#\#
         *  5.带副作用的宏参数
         *  6.宏和函数
         *  7.命名约定
     *  3、\#undef
     *  4、条件编译
     *  5、文件包含

## 一、程序环境 ##

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

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

> 第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。  
> 第2种是执行环境，它用于实际执行代码。

### 2、编译+链接 ###

#### 1.翻译环境 ####

*  组成一个程序的每个源文件通过编译过程分别转换成目标代码
 *  每个目标文件由链接器（linker）捆绑在一起，形成一个单一而完整的可执行程序。
 *  链接器同时也会引入标准C函数库中任何被该程序所用到的函数，而且它可以搜索程序员个人  
    的程序库，将其需要的函数也链接到程序中。

#### 2.翻译阶段 ####

![在这里插入图片描述][1634d43a24074091aeddc8653a9cb624.png]

#### 3.运行环境 ####

程序执行的过程：

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

## 二、预处理 ##

### 1、预定义符号 ###

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>FILE</strong></td> 
   <td>进行编译的源文件</td> 
  </tr> 
  <tr> 
   <td><strong>LINE</strong></td> 
   <td>文件当前的行号</td> 
  </tr> 
  <tr> 
   <td><strong>DATE</strong></td> 
   <td>文件被编译的日期</td> 
  </tr> 
  <tr> 
   <td><strong>TIME</strong></td> 
   <td>文件被编译的时间</td> 
  </tr> 
  <tr> 
   <td><strong>STDC</strong></td> 
   <td>如果编译器遵循ANSI C，其值为1，否则未定义</td> 
  </tr> 
 </tbody> 
</table>

#include <stdio.h>
    int main()
    {
        
    	printf("line:%d\n", __LINE__);
    	printf("date:%s\n", __DATE__);
    	printf("time:%s\n", __TIME__);
    	return 0;
    }

![在这里插入图片描述][01b0d943b99448c09298680c93de3826.png]

### 2、\#define ###

#### 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定义标识符的时候，最好不要在最后加上 ’;‘,容易发生错误

#### 2.\#define定义宏 ####

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

申明方式：

//其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。
    #define name( parament-list ) stuff
    //参数列表的左括号必须与name紧邻。
    //如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。

栗子：

#define A 2+2
    #define B 3+3
    #define C A*B
    int main()
    {
        
    //这里的宏C看起来是求A*B   结果为(2+2)*(3+3)=24
    //由于没有括号C算的其实是  2+2*3+3=11
    	printf("%d\n", C);
      return 0;
    }

![在这里插入图片描述][6237d7a618084c33a017980cb342e920.png]

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

#### 3.\#define替换规则 ####

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

注意：

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

#### 4.\#和\#\# ####

使用 \# ，把一个宏参数变成对应的字符串。

#define PRINT(n, format) printf("the value of "#n" is " format "\n", n)
    int main()
    {
        
    	int a = 20;
    	//printf("the value of a is %d\n", a);
    	PRINT(a, "%d");
    
    	int b = 15;
    	//printf("the value of b is %d\n", b);
    	PRINT(b, "%d");
    
    	float f = 4.5f;
    	//printf("the value of f is %f\n", f);
    	PRINT(f, "%f");
    	return 0;
    }

![在这里插入图片描述][d03982e70519419bac15dcfaff0ca9f9.png]

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

#define CAT(x,y) x##y
    //这样的连接必须产生一个合法的标识符，否则其结果就是未定义的
    int main()
    {
        
    	int peoplesum = 1000;
    	printf("%d\n", CAT(people, sum));
    	printf("%d\n", peoplesum);
    	return 0;
    }

![在这里插入图片描述][f1bc5aca064a460487e38429ac721522.png]

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

宏参数的副作用

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

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
    int main()
    {
        
    	int x = 5;
    	int y = 8;
    	int z = MAX(x++, y++);
    	//z = ( (x++) > (y++) ? (x++) : (y++));
    	//       5    >   8   ?         √
    	//     x=6      y=9            z=9,y=10
    	printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？
    	return 0;
    }

![在这里插入图片描述][65d2c0c396454f74978d284b01095442.png]

#### 6.宏和函数 ####

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

#### 7.命名约定 ####

> 把宏名全部大写 MAX  
> 函数名不要全部大写 Max

### 3、\#undef ###

用于移除一个宏定义

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

### 4、条件编译 ###

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

常见的条件编译指令：

1.  单个分支的条件编译

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

1.  多个分支的条件编译

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

1.  判断是否被定义

#if defined(symbol)
    #ifdef symbol
    
    #if !defined(symbol)
    #ifndef symbol

1.  嵌套指令

#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

### 5、文件包含 ###

\#include 指令可以使另外一个文件被编译。就像它实际出现于 \#include 指令的地方一样。  
预处理器先删除这条指令，并用包含文件的内容替换。  
这样一个源文件被包含10次，那就实际被编译10次。

可以利用条件编译避免头文件的重复引用

1.  每个文件开头写

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

1.  `#pragma once`

头文件被包含的方式

*  本地文件包含  
    `#include "filename"`

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

*  库文件包含  
    `#include <filename.h>`

直接去标准路径下去查找，如果找不到就提示编译错误。

![在这里插入图片描述][6467c2f3075149b1bbf8c58cc1682f77.png]

[1634d43a24074091aeddc8653a9cb624.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/447aa549175347678dbff62c2a25552a.png
[01b0d943b99448c09298680c93de3826.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/b0e071b729944e03874f0faa1185cb1a.png
[6237d7a618084c33a017980cb342e920.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/6120d54e171143b096f0ae84ac9676b4.png
[d03982e70519419bac15dcfaff0ca9f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/56574ee9bdfc45bf8622fccaed5ca930.png
[f1bc5aca064a460487e38429ac721522.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/f653082368774d43b76da7a90975c2c9.png
[65d2c0c396454f74978d284b01095442.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/705522e208ec4a4da9b15ed1ed8a44bc.png
[6467c2f3075149b1bbf8c58cc1682f77.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0bfb5394c91b41618f6d40d5f5cc1c2d.png