C语言，预处理命令

预处理命令基本介绍

1） 使用库函数之前，应该用#include 引入对应的头文件。这种以#号开头的命令称为预处理命令。
2） 这些在编译之前对源文件进行简单加工的过程，就称为预处理（即预先处理、提前处理）
3） 预处理主要是处理以#开头的命令，例如#include <stdio.h>等。预处理命令要放在所有函数之外，而且一般都放 在源文件的前面
4） 预处理是 C 语言的一个重要功能，由预处理程序完成。当对一个源文件进行编译时，系统将自动调用预处理程 序对源程序中的预处理部分作处理，处理完毕自动进入对源程序的编译
5） C 语言提供了多种预处理功能，如宏定义、文件包含、条件编译等，合理地使用它们会使编写的程序便于阅读、 修改、移植和调试，也有利于模块化程序设计

预处理命令快速入门

具体要求：

开发一个 C 语言程序，让它暂停 5 秒以后再输出内容 “helllo, world !~”，并且要求跨平台，在 Windows 和 Linux 下都能运行，如何处理？

提示

1）Windows 平台下的暂停函数的原型是 void Sleep(DWORD dwMilliseconds)，参数的单位是“毫秒”，位 于 <windows.h> 头文件。
2）Linux 平台下暂停函数的原型是 unsigned int sleep (unsigned int seconds)，参数的单位是“秒”，位于 <unistd.h> 头文件
3）#if、#elif、#endif 就是预处理命令，它们都是在编译之前由预处理程序来执行的。

代码实现

#include <stdio.h> 

//说明：在 windows 操作系统和 linux 操作系统下，生成源码不一样!!!
#if _WIN32 //如果是 windows 平台, 就执行 #include <windows.h> 
#include <windows.h> 
#elif __linux__ //否则判断是不是 linux ,如果是 linux 就引入<unistd.h> 
#include <unistd.h> 
#endif 

int main() { 

	//不同的平台下调用不同的函数 
	#if _WIN32  //识别 windows 平台 
	Sleep(5000); //毫秒

	#elif __linux__  //识别 linux 平台 
	sleep(5); //秒 
	#endif 
	
	puts("hello, world~"); 
	return 0; 
}

C 语言宏定义

基本介绍

1）#define 叫做宏定义命令，它也是 C 语言预处理命令的一种。所谓宏定义，就是用一个标识符来表示一个字符串，如果在后面的代码中出现了该标识符，那么就全部替换成指定的字符串
2）宏定义我们在讲解常量时，做过介绍，这里我们再系统的讲解一下.
3）快速回顾

#define N 100 

int main(){ 
	int sum = 20 + N;//int sum = 20 +100 
	printf("%d\n", sum); 
	return 0; 
}

小结:

int sum = 20 + N，N 被 100 代替了。
#define N 100 就是宏定义，N 为宏名，100 是宏的内容（宏所表示的字符串）。在预处理阶段，对程序中所有出现 的“宏名”，预处理器都会用宏定义中的字符串去代换，这称为“宏替换”或“宏展开”。 宏定义是由源程序中的宏定义命令#define 完成的，宏替换是由预处理程序完成的

宏定义的形式

#define 宏名 字符串

1）#表示这是一条预处理命令，所有的预处理命令都以 # 开头。宏名是标识符的一种，命名规则和变量相同。字 符串可以是数字、表达式、if 语句、函数等
2）这里所说的字符串是一般意义上的字符序列，不要和 C 语言中的字符串等同，它不需要双引号
3）程序中反复使用的表达式就可以使用宏定义。

宏定义#define 应用案例

体验一个一个宏展开的案例

#include <stdio.h> 


//宏定义 , 宏名 M , 对应的字符串 (n*n+3*n) //注意：如果宏对应的字符串 有 ( ) , 那么就不能省略 
#define M (n*n+3*n) 

int main(){ 
	int sum, n; 
	printf("Input a number: "); 
	scanf("%d", &n); //n = 3 
	sum = 3*M+4*M+5*M; // 宏展开 3*(n*n+3*n)+4*(n*n+3*n)+5*(n*n+3*n) 
	printf("sum=%d\n", sum);
	return 0; 
}

如果宏定义没有括号，那么下面的式子就会变成

3*n*n+3*n+4*n*n+3*n+5*n*n+3*n

宏定义注意事项和细节

1） 宏定义是用宏名来表示一个字符串，在宏展开时又以该字符串取代宏名，这只是一种简单的替换。字符串中可以含任何字符，它可以是常数、表达式、if 语句、函数等，预处理程序对它不作任何检查，如有错误，只能在编译已被宏展开后的源程序时发现。
2）宏定义不是说明或语句，在行末不必加分号，如加上分号则连分号也一起替换
3）宏定义必须写在函数之外，其作用域为宏定义命令起到源程序结束。如要终止其作用域可使用#undef 命令 [案例]

#define PI 3.14159 

int main(){ 
	printf("PI=%f", PI); 
	return 0; 
}

#undef PI //取消宏定义 
void func(){ 
	// Code 
	printf("PI=%f", PI);//错误,这里不能使用到 PI 了 
}

4）代码中的宏名如果被引号包围，那么预处理程序不对其作宏代替 [案例]

#include <stdio.h>
#define OK 100
int main(){
    printf("OK\n");
    return 0;
}

5) 宏定义允许嵌套，在宏定义的字符串中可以使用已经定义的宏名，在宏展开时由预处理程序层层代换 【案例】

#define PI 3.1415926 
#define S PI*y*y /* PI 是已定义的宏名*/ 

void main(){
	printf("%s", S); //在宏替换后变为： printf("%f", 3.1415926*y*y);
}

6）习惯上宏名用大写字母表示，以便于与变量区别。但也允许用小写字母
7）可用宏定义表示数据类型，使书写方便 [案例]

#define UINT int 

void main() { 
	UINT a, b; // 宏替换 int a, b; 
}

8）宏定义表示数据类型和用 typedef 定义数据说明符的区别：宏定义只是简单的字符串替换，由预处理器来处理；而 typedef 是在编译阶段由编译器处理的，它并不是简单的字符串替换，而给原有的数据类型起一个新的名字， 将它作为一种新的数据类型。

带参数的宏定义

基本介绍

1）C 语言允许宏带有参数。在宏定义中的参数称为“形式参数”，在宏调用中的参数称为“实际参数”，这点和 函数有些类似
2）对带参数的宏，在展开过程中不仅要进行字符串替换，还要用实参去替换形参
3）带参宏定义的一般形式为 #define 宏名(形参列表) 字符串 ,在字符串中可以含有各个形参
4）带参宏调用的一般形式为 : 宏名(实参列表); [案例+说明]

#include <stdio.h> 
//说明 
//1. MAX 就是带参数的宏 
//2. (a,b) 就是形参 
//3. (a>b) ? a : b 是带参数的宏对应字符串，该字符串中可以使用形参 
#define MAX(a,b) (a>b) ? a : b 

int main(){ 
	int x , y, max; 
	printf("input two numbers: "); 
	scanf("%d %d", &x, &y); 
	
	//说明 
	//1. MAX(x, y); 调用带参数宏定义 
	//2. 在宏替换时(预处理，由预处理器)， 会进行字符串的替换，同时会使用实参， 去替换形参
    //3. 即 MAX(x, y) 宏替换后 (x>y) ? x : y 
	
	max = MAX(x, y); 
	printf("max=%d\n", max); 
	return 0; 

}

带参宏定义的注意事项和细节

1）带参宏定义中，形参之间可以出现空格，但是宏名和形参列表之间不能有空格出现

#define MAX(a,b) (a>b)?a:b 如果写成了 
#define MAX (a, b) (a>b)?a:b 将被认为是无参宏定义，
宏名 MAX 代表字符串(a,b) (a>b)?a:b 
而不是 : MAX(a,b) 代表 (a>b) ? a: b 了

2）在带参宏定义中，不会为形式参数分配内存，因此不必指明数据类型。而在宏调用中，实参包含了具体的数据， 要用它们去替换形参，因此实参必须要指明数据类型
3）在宏定义中，字符串内的形参通常要用括号括起来以避免出错。

#include <stdlib.h> 
#define SQ(y) (y)*(y) // 带参宏定义,字符串内的形参通常要用括号括起来以避免出错 
int main(){
	int a, sq; 
	printf("input a number: "); 
	scanf("%d", &a); 
	sq = SQ(a+1); // 宏替换 (a+1) * (a+1) 
	printf("sq=%d\n", sq); 
	system("pause"); 
	return 0;
}

带参宏定义和函数的区别

1） 宏展开仅仅是字符串的替换，不会对表达式进行计算；宏在编译之前就被处理掉了，它没有机会参与编译，也 、不会占用内存。
2）函数是一段可以重复使用的代码，会被编译，会给它分配内存，每次调用函数，就是执行这块内存中的代码
3）案例说明 ：要求 使用函数计算平方值， 使用宏计算平方值， 并总结二者的区别

①函数计算平方值 ：

#include <stdlib.h> 
int SQ(int y){ 
	return ((y)*(y)); 
}

int main(){ 
	int i=1; 
	while(i<=5){ // 1, 4, 9, 16, 25 
		printf("%d^2 = %d\n", (i-1), SQ(i++)); 
	}
	system("pause"); 
	return 0;
}

②宏计算平方值

#include <stdlib.h> 

#define SQ(y) ((y)*(y)) 

int main(){ 
	int i=1; 
	while(i<=5){ // 这里相当于计算了 1,3,5 的平方 
	//进入循环 3 次，得到的是 1 * 1 = 1 3 * 3 = 9 , 5 * 5 = 25 
	// SQ(i++) 宏调用 展开 ((i++)*(i++)) 
		printf("%d^2 = %d\n", i, SQ(i++)); 
	}
	system("pause"); 
	return 0; 
}

在带参宏定义中，不会为形式参数分配内存，因此不必指明数据类型。而在宏调用中，实参包含了具体的数据，要用它们去代换形参，因此必须指明数据类型。

这一点和函数是不同的：在函数中，形参和实参是两个不同的变量，都有自己的作用域，调用时要把实参的值传递给形参；而在带参数的宏中，只是符号的替换，不存在值传递的问题。

在示例①中，先把实参 i 传递给形参 y，然后再自增 1，这样每循环一次 i 的值增加 1，所以最终要循环 5 次。
在示例②中，宏调用只是简单的字符串替换，SQ(i++) 会被替换为 ((i++)*(i++))，这样每循环一次 i 的值增加 2，所以最终只循环 3 次。
带参数的宏也可以用来定义多个语句，在宏调用时，把这些语句又替换到源程序中。
由此可见，宏和函数只是在形式上相似，本质上是完全不同的。

C 语言预处理命令总结

预处理指令是以#号开头的代码行，# 号必须是该行除了任何空白字符外的第一个字符。# 后是指令关键字， 在关键字和 # 号之间允许存在任意个数的空白字符，整行语句构成了一条预处理指令，该指令将在编译器进行编 译之前对源代码做某些转换

常见的预处理指令

指令	说明
#	空指令，无任何效果
#include	包含一个源代码文件
#define	定义宏
#undef	取消已定义的宏
#if	如果给定条件为真，则编译下面代码
#ifdef	如果宏已经定义，则编译下面代码
#ifndef	如果宏没有定义，则编译下面代码
#elif	如果前面的#if 给定条件不为真，当前条件 为真，则编译下面代码
#endif	结束一个#if……#else 条件编译块

预处理指令使用注意事项

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