C语言预处理详解

12ttt

于 2024-08-08 14:49:12 发布

阅读量692

点赞数 9

分类专栏： C语言文章标签： c语言 windows 开发语言

本文链接：https://blog.csdn.net/m0_72529141/article/details/141026768

版权

C语言专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本章重点：

预定义符号
#define定义常量
#define定义宏
带有副作用的宏参数
宏函数的对比
#和##
命名约定
#undef
命令行定义
条件编译
头文件的包含
其他预处理指令

1.预定义符号

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

__FILE__ //进行编译的源文件 
__LINE__ //文件当前的行号 
__DATE__ //文件被编译的日期 
__TIME__ //文件被编译的时间 
__STDC__ //如果编译器遵循ANSI C，其值为1，否则未定义

举例：

int main()
{
	printf("%s\n",__FILE__);
	printf("%d\n",__LINE__);
	printf("%s\n",__DATE__);
	printf("%s\n",__TIME__);
	printf("%d\n",__STDC__);
}

通过这些预定义符号，我们就可以直接得到我们想要的信息

2.`#define`

2.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__ )

2.2`#define`定义宏

#define机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏或者定义宏
下面是宏的申明方式：

#define name(parament-list) stuff

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

注意：
参数列表的左括号必须与name紧邻，如果有任何空白存在，参数列表就会被解释为stuff的一部分。
举例：
设置一个宏接收参数x，在下述声明后，把SQUARE(5);置于程序中，，预处理器就会用下面这个表达式替换上面的表达式：5 * 5

#define SQUARE(x) x*x

注意：在该举例中存在一个缺陷，观察下述代码

int main()
{
	int a = 5;
	printf("%d\n",SQUARE(a+1));
}

乍一看，我们可能会以为代码输出结果为36，然而实际输出结果为11。
在替换文本时，x被替换成a+1，所以语句实际上变成了：

printf("%d\n",a+1*a+1);//5+1*5+1=11

替换产生的表达式并没有按照预想的次序求职，其实，只需要加上两个括号即可

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

总结：
- 用于对数值表达式进行求值的宏定义

2.3`#define`后要不要加分号

例如：

#define MAX 1000;
int main()
{
	int a = 10;
	int b = 0;
	if(a > 5)
		b = MAX;//b=1000;;
	else
		b = -1;
	return 0;
}

如果加了分号，那么替换后，if和else之间就是两条语句，而没有大括号的时候，if后只能由一条语句，这里会出现语法错误

3.`#`和`##`

3.1`#`运算符

#运算符将宏的一个参数转换为字符串字面变量，它仅允许出现在带参数的宏的替换列表中，#运算符所执行的操作可理解为“字符串化。
当我们在使用函数时，难免会出现字符类型无法共同进行的现象，比如

int main()
{
	int a = 10;
	printf("the value of a is %d\n",a);
	int b = 23;
	printf("the value of b is %d\n",b);
	float c = 4.5f;
	printf("the value of c is %f\n",c);
}

在这种情况下，我们无法用一个函数来输出所有我们想要的结果，这时我们就可以使用宏

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

在PRINT中的替换：

#define PRINT(n,format) printf("the value of "#n" is "format"\n",n)
//替换后
#define PRINT(n,format) printf("the value of ""a"" is ""%d""\n",a)

#n $\rightarrow$ "a" format $\rightarrow$ "%d" n $\rightarrow$ a
#n $\rightarrow$ "b" format $\rightarrow$ "%d" n $\rightarrow$ b
#n $\rightarrow$ "c" format $\rightarrow$ "%f" n $\rightarrow$ c
就相当于把原本the value of a is %d这一个字符串拆分成多个字符串"the value of ""a"" is ""%d",这种写法在C语言中是可以存在的

3.2`##`的作用

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

#define CAT(v,n) v##n
int main()
{
	int value10 = 100;
	printf("%d\n",CAT(value,10));
}

结果为在这里插入图片描述

也就是说宏将value和10合并为了value10之后又将其打印

4.带副作用的宏参数

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

int main()  
{  
    int a = 10;  
    int b = a + 1;//让b得到11，a不会改变  
    int b = ++a;//让b得到11时，a也改变了---表达式有副作用  
    return 0;  
}

当a的值也随之改变的时候，表达式就具有了副作用
MAX宏可以证明具有副作用的参数引起的问题

#include <stdio.h>
#define MAX(a,b) ((a) > (b) ? (a) : (b))
int main()
{
	int x = 3;
	int y = 5;
	int m = MAX(x++,y++);
	printf("x=%d y=%d m=%d\n",x,y,m);
	return 0;
}

注意：

宏的替换不是将计算后的数替换进去，而是直接替换参数，替换结果如下

m = ((x++) > (y++) ? (x++) : (y++));
//    3    >  5    
//    a=4     b=6     no      6
//m=6 a=4                     b=7(使用后才会++，b使用了两                                   次，加两次)

结果：x=4,y=7,m=6

5.宏替换的规则

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

在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是它们首先被替换。
替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。
最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。
注意：
宏参数和#define定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

6.宏与函数的对比

宏常用于执行简单的运算

#include <stdio.h>
#define MAX(x,y) ((x) > (y) ? (x) : (y))
int Max(int x,int y)
{
	return x > y ? x : y; 
}
int main()
{
	int a = 10;
	int b = 20;
	int m1 = MAX(a,b);
	printf("%d\n",m1);

	int m2 = Max(a,b);
	printf("%d\n",m2);

	return 0;
}

两者都能找到较大的值，不用函数完成的原因有二：

用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹。
更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之这个宏总可以适用于整形、⻓整型、浮点型等可以用于>来比较的类型。宏是类型无关的。

宏的缺点：
1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的⻓度。
2. 宏是没法调试的。
3. 宏由于类型无关，也就不够严谨。
4. 宏可能会带来运算符优先级的问题，导致程容易出现错。
  宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。

#define MALLOC(num,type) (typr*)malloc(num*sizeof(type))
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	int* p = MALLOC(10,int);
	if(p == NULL)
	{
		//……
	}
}

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

在C++中引入了内联函数的概念inline具有函数和宏的双重优点

7.命名约定（习惯）

把宏名全部大写
函数名不要全部大写

8.`#undef`

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

#define M 100
int main()
{
	int m = M;
	printf("m = %d\n",m);
#undef M

#define M 1000
	int n = M;
	printf("n = %d\n",n);

	return 0;
}

输出结果：在这里插入图片描述

9.命令行定义

许多C的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。
举例：
当我们根据同一个源文件要编译出一个程序的不同版本的时候，这个特性有点用处。（假定某个程序中声明了一个某个⻓度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器内存大些，我们需要一个数组能够大些。）（不是变长数组，变长数组是与变量决定的，是在运行过程中）

#include <stdio.h>
int main()
{
	int arr[SZ];
	int i = 0;
	for(i = 0;i < SZ;i++)
	{
		arr[i] = i;
	}
	for(i = 0;i <SZ;i++)
	{
		printf("%d ",arr[i]);
	}
	return 0;
}

在这里我们并没有给SZ定义大小，那么在gcc环境中，在编译的过程中我们可以给其定义，这样就可以进行命令行定义的演示

gcc test.c -o test -D SZ=10

这样就为SZ定义了10的大小

10.条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件编译指令。
在大型工程中，条件编译用的是非常普遍的，调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。在跨平台的代码，也会需要条件编译。
常见的条件编译指令：

10.1`#if`……`#endif`

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

当常量表达式表达为真的时候就编译，为假不编译

int main()
{
#if 1
	printf("hehe\n");
#endif
	return 0;
}

1为真，所以会编译输出hehe
当表达式为假时，就不会进行

10.2多分支的条件编译

#if 常量表达式
//……
#elif 常量表达式
//……
#else
//……
#elif
……

相当于是#if……#endif的扩展

int main()
{
	#if 1==1
		printf("hehe\n");
	#elif 2==1
		printf("haha\n");
	#elif 3==1
		printf("heihei\n");
	#else
		printf("xixi\n");
	#endif
	return 0;
}

哪个条件满足，就会执行且只执行先满足的那一个，后边的就不会有机会了

10.3判断是否被定义

#if defined(symbol)//定义会进行
#ifdef symbol

#if !defined(symbol)//不定义才进行
#ifndef symbole

int main()
{
	#if defined(M)
		printf("hehe\n");
	#endif
	return 0;
}

我们在前面是没有定义过M的，所以说打印hehe的指令就不会进行，即使把M定义为0，打印指令也会进行，因为指令是否进行看的不是M的值，而是其是否被定义过

10.4嵌套指令

#if defined(OS_UNIX)
	#ifdef OPTION1
		unix_version_option1()
	#endif
#elif defined(OS_MSDOS) 
	#ifdef OPTION2 
		msdos_version_option2(); 
	#endif 
#endif

条件编译指令也是可以嵌套的

11.文件包含

#include指令可以使另一个文件被翻译，就像它实际出现于#include指令的地方

11.1头文件被包含的方式

11.1.1本地文件包含（自己的.h文件）

#include "filename"

查找策略：

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

#include "test.h"
int main()
{
	return 0;
}

对于这个test.h文件来说：

它会先在所在.c文件下查找
如果没找到，就会去标准库查找
找到了就可以编译，找不到就提示编译错误。
对于Linux系统标准头文件的路径：

/usr/include

11.1.2库文件包含(包含标准库的头文件)

#include <filename.h>

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

11.1.3对于库文件也可以使用 “” 的形式包含？

答案是肯定的，可以，但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。

11.2嵌套文件包含

如果出现这样的场景：
在这里插入图片描述

comm.h和comm.c是公共模块
test1.h和test.c使用了公共模块

//test.h
int Add(int x,int y);

///test.c
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"

int main()
{
	return 0;
}

头文件重复包含—浪费了空间—用条件编译指令在test.h中使用
test.h改完后：

//test.h
#ifndef __TEST_H__//一般根据头文件名字来起名称
#define __TEST_H__

int Add(int x,int y);

#endif

如果存在重复包含，我们只需要判断是否被定义过
定义过一次之后，第二次往后就不会定义（防止被重复包含）
另外一种改写方法：

//test.h
#pragma once

int Add(int x,int y);

12.其他预处理指令

#error
#pragma
#line
……

在这里插入图片描述

不做具体介绍

12ttt

关注

9
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录