C语言之预处理详情

最新推荐文章于 2024-11-13 20:19:40 发布
最新推荐文章于 2024-11-13 20:19:40 发布
阅读量867 收藏 10
点赞数 24
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74328241/article/details/141823874
版权

目录

前言

我们了解预处理有利于理解程序运行，自行查找问题以及代码修复。

1.预定义符号

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

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

测试代码如下：

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

VS2022 X64输出结果如下
在这里插入图片描述
VS未定义__STDC__ .
在这里插入图片描述

2.#define定义常量

基本语法：

#define name stuff

测试代码如下

#include <stdio.h>
#define MAX 100//定义常量
#define reg register//为关键字register创建一个简短的名字
#define do_forever for(;;)//死循环，用更形象的符号来替换一种实现
#define CASE break;case//在写case语句的时候自动加上break

//定义的stuff过长，可以分成几行写，除最后一行，每行后面加续行符'\'
#define DEBUG_PRINT printf("file:%s\nline:%d\n\
							date:%s\ntime:%s\n",\
							__FILE__,__LINE__,\
							__DATE__,__TIME__)
int main()
{
	//CASE测试
	int input = 1;
	switch(input)
	{
	case 0:
		//
	CASE 1:
		//
		break;
}
	//测试
	DEBUG_PRINT;
	return 0;
}

VS2022 X64输出结果如下
在这里插入图片描述
注：#define定义标识符最好不要在末尾加";"，因为#define name stuff就是将name换成stuff，如果是stuff;，原本的name就会被替换成stuff;

举个例子

#include <stdio.h>
#define M 100;
int main()
{
	int a = M;
	printf("%d\n", M);
	return 0;
}

上面的代码等价于下面的代码

#include <stdio.h>
int main()
{
	int a = 100;;//这个地方没问题，因为;等价于空语句
	printf("%d\n", 100;);//但是这个地方影响打印，会报错
	if(1)
		a = M;//这个地方也有问题，因为if后没有{}，只能跟一条语句，现在是两条语句
	else
		a = 0;
	return 0;
}

VS2022 X64系统如下
在这里插入图片描述

3.#define定义宏

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

#define name(parament-list) stuff

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

举个例子：

#define SQUARE(x) x*x

该宏接收参数x，用x*x的值代替SQUARE(x).
测试代码如下：

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

VS2022 X64输出结果如下

25
11

其实宏替换的时候是直接替换，不会对传入的表达式进行计算，所以SQUARE(5+1)等价于5+1*5+1，因此第二行的结果是11.

所以我们要考虑在参数的外面带上括号，防止由于相邻操作符优先级的关系导致结果有误差。

对宏定义修改后，下面代码的输出结果是36.

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

最安全的方式其实是在最后结果也加上括号，如下代码所示。

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

比如下面这段代码输出结果是66，是10*(5+1)+(5+1)，但我们想要的是10ADD(6)，也就是1012=120.

#include <stdio.h>
#define ADD(x) (x)+(x)
int main()
{
	printf("%d\n", 10*ADD(5 + 1));
	return 0;
}

修改后的代码如下所示，输出结果是120.

#include <stdio.h>
#define ADD(x) ((x)+(x))
int main()
{
	printf("%d\n", 10*ADD(5 + 1));
	return 0;
}

综上所述，宏定义要注意在各个参数以及最终结果加上括号。

4.带有副作用的宏参数

比如前置、后置++（–）会对参数本身进行修改，所以我们在定义宏的时候，如果传入的参数是a++等内容，特别是多次替换的情况下，由于参数本身被修改，结果将会是不可预测的。

举个例子：

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

代码int z = MAX(x++, y++);等价于int z = ((x++)>(y++)?(x++):(y++));后置++是先使用后++，首先进行x与y的比较，x<y，且此时x变成6，y变成9，执行z = y++，z变成9，y+1变成10.

VS2022 X64输出结果如下

6 10 9

但是我们想要的是x和y进行比较，将较大的值赋给z.

当然这个例子感觉有些“为赋新词强说愁”的意味，但是有时候确实会存在参数自身发生变化导致宏结果的不确定性。所以在使用宏的时候尽量不要去传带有++、- -这些运算符的参数，很容易出现意想不到的结果。

5.宏替换的规则

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

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

注意：

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

举例说明第二点如下所示：

#include <stdio.h>
#define MAX(a,b) ((a)>(b)?(a):(b))
int main()
{
	int a = MAX(3, 4);
	printf("MAX(3,4)=%d\n",a);//字符串中的宏不会被替换
	return 0;
}

VS2022 X64输出结果如下

MAX(3,4)=4

6.宏和函数的对比

宏通常被应用于执行简单的运算，比如在两个数字=中找出较大的一个时，写成下面的宏，更有优势一些。

#define MAX(a,b) ((a)>(b)?(a):(b))

为什么不用函数来完成这个任务呢？
原因有二：

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

和函数相比宏的劣势：

  1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。
  2. 宏是没法调试的。
  3. 宏由于类型无关，也就不够严谨。
  4. 宏可能带来运算符优先级的问题，导致结果可能不确定。

宏有时候可以做函数做不到的事情，比如，宏的参数可以出现类型，但是函数不可以。

举例代码如下：

#include <stdio.h>
#include <stdlib.h>
#define MALLOC(num,type)\
	(type*)malloc(num*sizeof(type))
int main()
{
	int* p= MALLOC(10, int);
	if (p = NULL)
	{
		perror("MALLOC");
		return 1;
	}
	for (int i = 0; i < 10; i++)
		p[i] = i + 1;
	for (int i = 0; i < 10; i++)
		printf("%d ",p[i]);
	return 0;
}

综上，宏和函数的比较如下：
在这里插入图片描述

7.#和##运算符

7.1 #运算符

#运算符将宏的一个参数转换为字符串字面量，仅出现在带参数的宏替换列表中。
对于变量a，其值为10，我们想打印：the value of a is 10.
可以用以下宏定义：

#define PRINT(n) printf("the value of " #n " is %d\n",n)
//同一行多个字符串打印的时候会自动拼接，#n会自动转化为字符串

举例如下：

#include <stdio.h>
#define PRINT(n) printf("the value of " #n " is %d\n",n)
int main()
{
	int a=10,b=11,c=12;
	PRINT(a);
	PRINT(b);
	PRINT(c);
	return 0;
}

VS2022 X64输出结果如下所示
在这里插入图片描述

7.2 ##运算符

##运算符可以把位于其两侧的符号合成一个符号，允许宏定义从分离的文本片段创建标识符，##被称为记号粘合。

这样的连接必须产生一个合法的标识符，否则其结果就是未定义。

举个例子，写一个函数求两个数较大值，不同的数据类型就要写不同的函数。

int int_max(int x, int y)
{
	return x > y ? x : y;
}
float float_max(float x, float y)
{
	return x > y ? x : y;
}

如果我们用下面这种方式，

#define GENERIC_MAX(type)\
type type##_max(type x,type y)\
{\
	return x > y ? x : y;\
}
GENERIC_MAX(int)
GENERIC_MAX(float)
int main()
{
	int a = int_max(2, 3);
	printf("%d\n", a);
	float b = float_max(2, 3);
	printf("%f\n", b);
	return 0;
}

VS2022 X64输出结果如下所示

3
3.000000

在实际开发中##使用较少，很难举出非常贴切的例子。

8.命名约定

一般来讲，函数和宏的使用语法很相似，
命名习惯为：宏定义一般都会将name的所有字母设置为大写，函数名一般只有开头字母大写。

9.undef

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

#define M 10
#undef M//首先移除旧的宏定义名，才能重新定义
#define M 10

10.命令行指令

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

11.条件编译

在编译一个程序的时候，可以使用条件语句选择性编译语句。
比如：调试性的代码。

#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__ 
	printf("haha\n");
#endif

2.多个分支的条件编译

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

举例代码如下：

#include <stdio.h>
#define __DEBUG__ 2
#if __DEBUG__==0
	printf("hehe\n");
#elif __DEBUG__==1
	printf("haha\n");
#else 
	printf("heihei\n");
#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

12.头文件的包含

12.1 头文件包含方式

12.1.1 本地头文件包含

#include "filename"

查找策略：先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找文件。
Linux环境的标准头文件路径：

/usr/include

VS环境的标准头文件路径：

C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
//这是VS2013的默认路径

根据安装路径去找。

12.1.2 库文件包含

#include <filename.h>

一般标准头文件格式为#include <stdio.h>，即使用<>，而不是""；使用""的头文件查找策略如上所述，使用<>的头文件会直接在标准位置查找。所以，如果对库文件使用""，会先在目录文件下寻找，但这是浪费时间的，效率较低，并且也不容易区分到底是库文件还是本地文件。

12.2 嵌套文件包含

#include指令可以使一个文件被编译，预处理会将这条指令的内容替换为该文件包含的内容。
但是，如果多次引用头文件，头文件内容就会被多次包含，对编译的压力比较大。
test.h

void test();
struct Stu
{
	int id;
	char name[20];
};

test.c

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

如果是这样的话，test.c文件将5次包含test.h的内容，如果tets.h内容比较多，预处理代码剧增。如果工程较大，公共使用的头文件被多次引用，不做任何处理，导致预处理后的代码冗余。

每个头文件的开头写：

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

或者

#pragma once

可以避免头文件的重复引入
注：推荐《⾼质量C/C++编程指南》中附录的考试试卷（很重要）。
笔试题：

  1. 头⽂件中的 ifndef/define/endif是⼲什么用的?
  2. #include <filename.h> 和 #include “filename.h” 有什么区别?

13.其他预处理指令

#error
#pragma
#line
...//大家有兴趣自行了解
#pragma pack()//用于改变编译器结构体的默认对齐数

参考《C语言深度解剖》学习。

总结

“路漫漫其修远兮，吾将上下而求索。”是C语言最后一篇啦，下次就是数据结构啦！头文件、宏定义等内容比较多，记得消化哟~

顾紫荆
关注
专栏目录
C语言编译预处理详解
喜欢编程，将自己会的知识分享给大家
10-23 3960
C语言由源代码生成可执行程序的过程：C源程序－>编译预处理－>编译－>优化程序－>汇编程序－>链接程序－>可执行文件其中编译预处理阶段，读取C源程序，对其中的预处理指令（以#开头的指令）和特殊符号进行处理预处理过程先于编译器对源代码进行处理，读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行转换。预处理过程还会删除程序中的注释和多余的空白字符使用#define命令并不是真正的定义符号常量，而是定义一个可以替换的宏。被定义为宏的标识符称为“宏名”。
C语言-预处理详解
linkang007的博客
05-29 2127
C语言-预处理详解
C语言之预处理详解（完结撒花）
x_p96484685433的博客
09-18 1386
本文为我的C语言系列的最后一篇文章，主要讲述了#define定义和宏、#和##运算符、各种条件编译指令等，希望对大家有所帮助。
c语言的预处理指令
liangmeirong123的博客
09-19 1299
文章目录1.预定义符号2.`#define`2.1`#define定义常量`2.2`#define定义宏`2.2.1宏的概念2.2.2宏的副作用2.2.3宏的替换规则3.宏和函数的对比3.1宏和函数的命名4.`#`运算符和`##`运算符4.1`#`运算符4.2`##`运算符5.`#`undef6.条件编译7.头文件的包含 预定义符号 #define 宏和函数的对比 #运算符和##运算符 #undef 条件编译 头文件的包含 避免头文件重复引用的方法 1.预定义符号 C语言设置了一些预定义符号，可以直接使
C语言学习之预处理
忆梦初心的博客
01-10 3435
我们用C语言直接写出来的代码是不能被计算机进行识别的，这其中需要进行一系列过程使源码转换成计算机所能识别的二进制语言，这一系列过程就叫做翻译。源码翻译过程主要有四步：预处理头文件展开去注释宏替换条件编译等编译：将C语言翻译成汇编语言汇编：将汇编语言转化为可重定向目标文件(可被链接，已经是二进制，但不是可执行文件)链接：自身程序+库文件进行关联，形成可执行程序本篇文章我们就来谈谈预处理这个环节，并了解如何定义宏，如何进行条件编译。在C语言中，我们通常使用。
【C语言】预处理
Qiuhan_909的博客
02-22 2539
1. 从源文件到可执行文件的过程 2. 预处理指令 3. 宏定义 4. 文件包含 5. 条件编译
【C语言】预处理详解
weixin_63246064的博客
04-12 1709
文章目录一、预定义符号二、#define定义2.1.#define定义标识符2.2.#define定义宏2.3.#define替换规则2.4.#和##（1）#号可以将宏中的参数转化为对应字符串（2）## 把位于符号两边的符号合成一个符号2.5.带副作用的宏参数2.6.宏和函数对比2.7.命名约定三、#undef四、命令行定义五、条件编译六、文件包含6.1.头文件被包含的方式6.2.嵌套头文件包含 一、预定义符号 __ FILE__ //进行编译的源文件 __ LINE__ //文件当前的
c语言-编译预处理
m0_71813740的博客
08-05 1028
h文件中使用较多。
C语言预处理
qq_61872165的博客
07-20 3122
一.预定义符号 二.#define 1.#define定义的标识符常量 2.#define定义宏 3.#define替换规则 4.#和## 5.带副作用的宏参数 6.宏和函数的比较 7.命名约定 三.#undef 四.命令行定义 五.条件编译 1.#if defined（#ifdef） 2.#if !defined（#ifndef） 3.#if 4.嵌套指令 六.文件包含 七.其它预处理指令...
c语言的预处理
south_windOvO的博客
07-22 930
c语言的每生成可执行程序（后缀.exe的文件）时都要经过2个过程编译和链接。编译把c语言代码转换成汇编代码，（语法分析，词法分析，符号汇总，语法分析）预处理1.头文件的包含2.#define定义符号的替换3.注释的删除。汇编把汇编代码转换成二进制指令，形成符号表（编译时的符号汇总）__FILE__//进行编译的源文件。__DATE__//文件被编译的日期。__TIME__//文件被编译的时间。##号的作用可以把位于它两边的符号合成一个符号。...
c语言预处理和条件编译
11-09
### C语言预处理和条件编译 #### 预处理 预处理是C语言程序编译过程中的第一个阶段，它负责处理源代码中的预处理器指令。预处理器指令以`#`字符开头，这些指令告诉预处理器如何处理接下来的代码。 ##### 头文件...
c语言中预处理都有哪些类型,c语言中预处理命令都有哪些
weixin_31411313的博客
05-22 962
匿名用户1级2017-12-21 回答我们可以在C源程序中插入传给编译程序的各中指令，这些指令被称为预处理器指令，它们扩充了程序设计的环境。现把常用的预处理命令总结如下：1. 预处理程序按照ANSI标准的定义，预处理程序应该处理以下指令：#if #ifdef #ifndef #else #elif#endif#define#undef#line#error#pragma#include显...
C语言 | Leetcode C语言题解之第559题N叉树的最大深度
m0_59237910的博客
11-12 351
C语言 | Leetcode C语言题解之第559题N叉树的最大深度
C语言 | Leetcode C语言题解之第552题学生出勤记录II
m0_59237910的博客
11-09 399
C语言 | Leetcode C语言题解之第552题学生出勤记录II
c语言基础知识点（十五）C语言中的指针+1与指针的二进制表示+1的区别
最新发布
qq_51519091的博客
11-13 164
给一个指针加上一个整数与给该指针的二进制表示加上同样的整数，这两者之间存在本质的区别，主要体现在操作对象、操作意义以及结果上。
C语言 | Leetcode C语言题解之第554题砖墙
m0_59237910的博客
11-10 315
C语言 | Leetcode C语言题解之第554题砖墙
结构体（c语言）
2402_86350741的博客
11-13 849
位段相对于结构体，可以省略很多空间，但是有跨平台问题出现。
【C语言】函数递归
2302_81083101的博客
11-13 724
其实我们在前面的学习中已经使用过函数的递归了。那么什么是递归呢递归是一种解决问题的方法，就是函数自己调用自己，例如下面的函数。上面就是一个简单的函数递归，在main函数内调用自己。
java项目，课程设计-ssm病人跟踪治疗信息管理系统
11-13
病人跟踪治疗信息管理系统采用B/S模式，促进了病人跟踪治疗信息管理系统的安全、快捷、高效的发展。传统的管理模式还处于手工处理阶段，管理效率极低，随着病人的不断增多，传统基于手工管理模式已经无法满足当前病人需求，随着信息化时代的到来，使得病人跟踪治疗信息管理系统的开发成了必然。 本网站系统使用动态网页开发SSM框架，Java作为系统的开发语言，MySQL作为后台数据库。设计开发了具有管理员；首页、个人中心、病人管理、病例采集管理、预约管理、医生管理、上传核酸检测报告管理、上传行动轨迹管理、分类管理、病人治疗状况管理、留言板管理、系统管理，病人；首页、个人中心、病例采集管理、预约管理、医生管理、上传核酸检测报告管理、上传行动轨迹管理、病人治疗状况管理，前台首页；首页、医生、医疗资讯、留言反馈、个人中心、后台管理、在线咨询等功能的病人跟踪治疗信息管理系统。在设计过程中，充分保证了系统代码的良好可读性、实用性、易扩展性、通用性、便于后期维护、操作方便以及页面简洁等特点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值