C语言入门系列之9.预处理

川长思鸟来 2023-03-13 05:52 42阅读 0赞

### 文章目录 ###

*  一、无参宏定义
 *   *  1.基本使用
     *  2.注意事项
 *  二、带参宏定义
 *   *  1.基本概念
     *  2.注意事项
 *  三、文件包含
 *  四、条件编译
 *  五、预处理小结

在之前，已多次使用过以\#号开头的预处理命令，如包含命令 `#include <stdio.h>`、宏定义命令 `#define PI 3.1415926535`等。  
在源程序中这些命令都放在函数之外，而且一般都放在源文件的前面，它们称为 **预处理**部分。

# 一、无参宏定义 #

## 1.基本使用 ##

无参宏的宏名后不带参数。  
其定义的一般形式为：

#define 标识符 字符串

其中的\#表示这是一条预处理命令，凡是以\#开头的均为预处理命令；  
define为宏定义命令；  
标识符为所定义的宏名；  
字符串可以是常数、表达式、格式串等。

例如`#define PI 3.1415926535`，它的作用是指定标识符PI来代替数3.1415926。

在编写源程序时，所有的3.1415926535都可由PI代替，而对源程序作编译时，将先由预处理程序进行宏代换，即用3.1415926535表达式去置换所有的宏名PI，然后再进行编译。

练习：

#include <stdio.h>
    
    #define PI 3.1415926535
    
    int main(){ 
    	double s;
    	int r;
    	printf("Please input the radius:\n");
    	scanf("%d", &r);
    	s = PI * r * r;
    	printf("s = %6.2lf", s);
    	
    	return 0;
    }

打印：

Please input the radius:
    12
    s = 452.39

## 2.注意事项 ##

（1）宏定义是用宏名来表示一个字符串，在宏展开时又以该字符串取代宏名，这只是一种**简单的代换**，字符串中可以包含任何字符，可以是常数，也可以是表达式，预处理程序对它不作任何检查。如有错误，只能在编译已被宏展开后的源程序时发现。

（2）宏定义不是说明或语句，在行末不必加分号，如加上分号则连分号也一起置换。

（3）宏定义必须写在函数之外，其作用域为**宏定义命令起到源程序结束**，如要终止其作用域可使用`#undef`命令。

（4）宏名在源程序中若用引号括起来，则预处理程序不对其作宏代换。

练习：

#include <stdio.h>
    
    #define PI 3.1415926535
    
    int main(){ 
    	void func(void);
    	double s;
    	int r;
    	printf("Please input the radius:\n");
    	scanf("%d", &r);
    	s = PI * r * r;
    	printf("s = %6.2lf\n", s);
    	func();
    	
    	return 0;
    }
    
    void func(void){ 
    	printf("Now the PI = %g\n", PI);
    	printf("PI");
    }

打印：

Please input the radius:
    12
    s = 452.39
    Now the PI = 3.14159
    PI

（5）宏定义允许**嵌套**，在宏定义的字符串中可以使用已经定义的宏名。  
在宏展开时由预处理程序层层代换。

练习：

#include <stdio.h>
    
    #define PI 3.1415926535
    #define S PI*r*r
    
    int main(){ 
    	void func(void);
    	double s;
    	int r;
    	printf("Please input the radius:\n");
    	scanf("%d", &r);
    	s = S;
    	printf("s = %6.2lf\n", s);
    	
    	return 0;
    }

运行效果与之前相同。

（6）习惯上宏名用大写字母表示，以便于与变量区别。  
但也允许用小写字母。

（7）可用宏定义表示数据类型，使书写方便。  
例如`#define INTEGER int`。

注意，宏定义表示数据类型和用`typedef`定义数据说明符存在一定的区别：  
宏定义只是简单的字符串代换，是在预处理完成的，而`typedef`是在编译时处理的，它不是作简单的代换，而是对类型说明符重新命名。  
被命名的标识符具有类型定义说明的功能。

练习：

#include <stdio.h>
    
    #define PIN1 char*
    typedef char* PIN2;
    
    
    int main(){ 
    	PIN1 x, y;
    	PIN2 a, b;
    	printf("By #define: %d %d\n", sizeof(x), sizeof(y));
    	printf("By typedef: %d %d\n", sizeof(a), sizeof(b));
    	
    	return 0;
    }

打印：

By #define: 8 1
    By typedef: 8 8

显然，两者是有区别的，宏定义是字符串替换，所以`PIN1 x, y;`语句等价于`char* x, y`，即`char *x, y`，x为字符型指针，占8个字节，y为字符，占1个字节；  
typedef是类型定义，所以`PIN2 a, b;`语句等价于`char* a, b;`，即`char *a, *b;`，a、b均为字符型指针，占8个字节。

（8）对**输出格式**作宏定义，可以减少书写麻烦。

练习：

#include <stdio.h>
    
    #define P printf
    #define D "%d\n"
    #define F "%f\n"
    
    int main(){ 
    	int a = 3, c = 4, e = 5;
    	float b = 1.2, d = 2.3, f = 3.4;
    	P(D F, a, b);
    	P(D F, c, d);
    	P(D F, e, f);
    	
    	return 0;
    }

打印：

3
    1.200000
    4
    2.300000
    5
    3.400000

# 二、带参宏定义 #

## 1.基本概念 ##

C语言允许宏带有参数。  
在宏定义中的参数称为形式参数，在宏调用中的参数称为实际参数。

对带参数的宏，在调用中，不仅要宏展开，而且要用实参去代换形参。

带参宏定义的一般形式为：

#define 宏名(形参表) 字符串

带参宏调用的一般形式为：

宏名(实参表);

例如:

#define M(y) y*y+3*y /*宏定义*/
    ……
    k=M(5);                   /*宏调用*/
    ……

在宏调用时，用实参5去代替形参y，经预处理宏展开后的语句为`k=5*5+3*5`。

练习如下：

#include <stdio.h>
    
    #define MAX(a, b) (a > b) ? a:b 
    
    int main(){ 
    	int x, y, max;
    	printf("Input 2 numbers:\n");
    	scanf("%d %d", &x, &y);
    	max = MAX(x, y);
    	printf("Max = %d\n", max);
    	
    	return 0;
    }

打印：

Input 2 numbers:
    12 20
    Max = 20

## 2.注意事项 ##

（1）带参宏定义中，宏名和形参表之间不能有空格出现。  
例如把`#define MAX(a,b) (a>b)?a:b`写为`#define MAX (a,b) (a>b)?a:b`会报错。

（2）在带参宏定义中，形式参数不分配内存单元，因此不必作类型定义；  
而宏调用中的实参有具体的值，要用它们去代换形参，因此必须作类型说明。  
这与函数中的情况是不同的：  
在函数中，形参和实参是两个不同的量，各有自己的作用域，调用时要把实参值赋予形参，进行**值传递**；  
而在带参宏中，只是**符号代换**，不存在值传递的问题。

（3）在宏定义中的形参是标识符，而宏调用中的实参可以是表达式。

练习：

#include <stdio.h>
    
    #define SAY(y) y+5 
    
    int main(){ 
    	int i = 0;
    	char say[] = { 73, 52, 108, 111, 118, 101, 32, 102, 105, 115, 104, 79, 46, 99, 91, 109};
    	while(say[i]){ 
    		say[i] = SAY(say[i] * 0.8);
    		i++;
    	}
    	printf("%s\n", say);
    	
    	return 0;
    }

打印：

?.[]cUVYaXD)TM\e

（4）在宏定义中，字符串内的形参通常要用括号括起来以避免出错。

练习如下：

#include <stdio.h>
    
    #define SQ1(y) (y)*(y)
    #define SQ2(y) y*y
    
    int main(){ 
    	int a, sq1, sq2;
    	printf("Input a number:\n");
    	scanf("%d", &a);
    	sq1 = SQ1(a+1);
    	sq2 = SQ2(a+1);
    	printf("SQ1 = %d\nSQ2 = %d\n", sq1, sq2);
    	
    	return 0;
    }

打印：

Input a number:
    3
    SQ1 = 16
    SQ2 = 7

显然，加括号与不加括号的效果是不一样的。

进一步改进：

#include <stdio.h>
    
    #define SQ1(y) (y)*(y)
    #define SQ2(y) ((y)*(y))
    
    int main(){ 
    	int a, sq1, sq2;
    	printf("Input a number:\n");
    	scanf("%d", &a);
    	sq1 = 32 / SQ1(a+1);
    	sq2 = 32 / SQ2(a+1);
    	printf("SQ1 = %d\nSQ2 = %d\n", sq1, sq2);
    	
    	return 0;
    }

打印：

Input a number:
    3
    SQ1 = 32
    SQ2 = 2

显然，我们要用32除以SQ的值的话，必须要在外面再加一个括号，使之成为一个整体。

（5）带参的宏和带参函数很相似，但有本质上的不同，除上面已谈到的各点外，把同一表达式用函数处理与用宏处理两者的结果有可能是不同的。

函数方式练习：

#include <stdio.h>
    
    int main(){ 
    	int i = 1;
    	int SQ(int y);
    	while(i <= 5){ 
    		printf("%d\n", SQ(i++));
    	}
    	
    	return 0;
    }
    
    int SQ(int y){ 
    	return ((y) * (y));
    }

打印：

1
    4
    9
    16
    25

宏方式练习：

#include <stdio.h>
    
    #define SQ(y) ((y)*(y))
    
    int main(){ 
    	int i = 1;
    	while(i <= 5){ 
    		printf("%d\n", SQ(i++));
    	}
    	
    	return 0;
    }

打印：

2
    12
    30

显然，两者的结果不同，因为在使用宏的方式时，只是简单的字符串替换，每次字符串替换都会执行两次i++，所以第一次为1×2，第2次为3×4，第3次为5×6，导致结果不同。

（6）宏定义也可用来定义多个语句，在宏调用时，把这些语句又代换到源程序内。

练习：

#include <stdio.h>
    #include <string.h>
    
    #define STR(s1, s2, s3, sum) strcat(strcat(strcat(sum, s1), s2), s3)
    
    int main(){ 
    	char str1[] = "I ", str2[] = "love ", str3[] = "C!", str[40] = "";
    	STR(str1, str2, str3, str);
    	printf("str1 = %s\nstr2 = %s\nstr3 = %s\nstr = %s\n", str1, str2, str3, str);
    	
    	return 0;
    }

打印：

str1 = I
    str2 = love
    str3 = C!
    str  = I love C!

进一步扩展：

打印：

str1 = I
    str2 = love
    str3 = C!
    str  = I love C!
    
    str1 = I
    str2 = love
    str3 = C!
    str  = C!I love

# 三、文件包含 #

文件包含之前已经用到了很多，如`#include <stdio.h>`、`#include <string.h>`等。

文件包含命令的注意点：

1.  一个include命令只能指定一个被包含文件，若有多个文件要包含，则需用多个include命令。
2.  文件包含允许嵌套，即在一个被包含的文件中又可以包含另一个文件。
3.  包含命令中的文件名可以用双引号括起来，也可以用尖括号括起来。例如以下写法都是允许的：

#include "stdio.h"
    #include <math.h>

但是这两种形式是有区别的：  
使用尖括号表示在**包含文件目录**中去查找(包含目录是由用户在配置环境时设置的)，而不在源文件目录去查找；  
使用双引号则表示首先在当前的**源文件目录**中查找，若未找到才到包含目录中去查找。

用户编程时可根据需要包含的文件所在的目录来选择某一种命令形式。

# 四、条件编译 #

预处理程序提供了条件编译的功能，可以按不同的条件去编译不同的程序部分，因而产生不同的目标代码文件。  
这对于程序的移植和调试是很有用的。

条件编译有三种形式：

1.  第一种形式：

#ifdef 标识符
    	程序段1
    #else
    	程序段2
    #endif

它的功能是，如果标识符已被`#define`命令定义过则对程序段1进行编译；否则对程序段2进行编译。  
如果没有程序段2(为空)，本格式中的`#else`可以没有，即可以写为：

#ifdef 标识符
      	程序段
    #endif

1.  第二种形式：

#ifndef 标识符
      	程序段1
    #else
      	程序段2
    #endif

练习：

#include <stdio.h>
    
    #define CORRECT "corley.com"
    
    int main(){ 
    	char str[40];
    	int cmp(char *str1, char *str2);
    	printf("Input the website you like best:\n");
    	scanf("%s", str);
    	
    #ifndef CORRECT
    #define CORRECT "corley.com"
    #endif
    
    	if(cmp(str, CORRECT) == 0){ 
    		printf("You are so cute!\n");
    	}
    	else{ 
    		printf("You are a bad guy!\n");
    	}
    	
    	return 0;
    }
    
    int cmp(char *str1, char *str2){ 
    	int i = 0, j = 0;
    	while(str1[i]){ 
    		while(str2[j] == str1[i]){ 
    			i++;
    			j++;
    			if(!str2[j]){ 
    				return 0;
    			}
    		}
    		j = 0;
    		i++;
    	}
    	return -1;
    }

打印：

Input the website you like best:
    corley.com
    You are so cute!

1.  第三种方式：

#if 常量表达式
       	程序段1
    #else 
       	程序段2
    #endif

练习：

#include <stdio.h>
    
    #define ROUND 1
    #define PI 3.14159
    
    int main(){ 
    	int r;
    	double s;
    	printf("Input the radius:\n");
    	scanf("%d", &r);
    
    #if ROUND
    	s = r * r * PI;
    	printf("Area of circle is: %6.2f\n", s);
    #else
    	s = r * r;
    	printf("Area of square is: %6.2f\n", s);
    #endif
    	
    	return 0;
    }

打印：

Input the radius:
    12
    Area of circle is: 452.39

# 五、预处理小结 #

1.  预处理功能是C语言特有的功能，它是在对源程序正式编译前由预处理程序完成的，开发者在程序中用预处理命令来调用这些功能。
2.  宏定义是用一个标识符来表示一个字符串，这个字符串可以是常量、变量或表达式。  
    在宏调用中将用该字符串代换宏名。
3.  宏定义可以带有参数，宏调用时是以**实参代换形参**，而不是**值传送**。
4.  为了避免宏代换时发生错误，宏定义中的字符串应**加括号**，字符串中出现的形式参数两边也应加括号。
5.  文件包含是预处理的一个重要功能，它可用来把多个源文件连接成一个源文件进行编译，结果将生成一个目标文件。
6.  条件编译允许只编译源程序中满足条件的程序段，使生成的目标程序较短，从而减少了内存的开销并提高了程序的效率。
7.  使用预处理功能便于程序的修改、阅读、移植和调试，也便于实现模块化程序设计。