预处理详解

于 2024-09-16 20:39:35 发布
阅读量891 收藏 11
点赞数 14
分类专栏： c语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79391723/article/details/142304863
版权

今天大家一起来学习预处理

在这里插入图片描述

目录

1.预处理符号

如下：

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

代码举例

printf("file:%s line:%d\n",__FILE__,__LINE__);

2.#difine

2.1#difine定义常量

2.1.1基本语法

#difine name stuff
代码举例
//#difine MAX 1000
//#difine reg register  //为 Register 这个关键字创建一个简短的名称
//#difine do_forever for(;;) //⽤更形象的符号来替换⼀种实现
//#difne CASE break;case  //自动在 case 后面添加 break
//如果定义的 stuff过⻓，可以分成⼏⾏写，
//除了最后一⾏外，每⾏的后⾯都加⼀个反斜杠(续行符)。
//#difine DEBUG_PRINT printf(line:%d\t time:%s\t \
							 date:%s\t file;%s\n, \
							 __LINE__,__TIME__, \
							 __DATE__,__FILE__)

2.1.2思考：在define定义标识符的时候，要不要在最后加上 ; ?

代码
#difine MAX 1000;
#difine MAX 1000

建议不要加上 ; ,这样容易导致问题。

代码
if (condition)
	max = MAX;
else
	return 0;

如果是加了分号的情况，等替换后，if和else之间就是2条语句，
而没有大括号的时候，if后边只能有一条语句。
这里会出现语法错误。

2.2#difine定义宏

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

2.2.1声明方式

#difine name(prament-list) stuff

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

注意：
参数列表的左括号必须与name紧邻，如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。

举例

#difine SQUARE(x) x*x;

这个宏接收一个参数 x .如果在上述声明之后，
你把 SQUARE( 5 )置于程序中，
预处理器就会用这个表达式替换表达式： 5 * 5

警告：
这个宏存在⼀个问题：

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

乍⼀看，你可能觉得这段代码将打印36，事实上它将打印11，
替换⽂本时，参数x被替换成a + 1,所以这条语句实际上变成了：

printf("%d\n",a+1*a+1)

这样就比较清晰了，
由替换产生的表达式并没有按照预想的次序进行求值。

在宏定义上加上两个括号，这个问题便轻松的解决了

#difine SQUARE(x) (x)*(x);

另⼀个宏定义：

#difne DOUBLE(x) (x)+(x)

定义中我们使用了括号，想避免之前的问题，但是这个宏可能会出现新的错误

int a = 5;
printf("%d\n",10*DOUBLE(a))

看上去，好像打印100，但事实上打印的是55，
乘法运算先于宏定义的加法，所以出现了 55
解决办法是在宏定义表达式两边加上⼀对括号就可以了

#difine DOUBLE(x) ((x)+(x))

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

3.带有副作用的宏参数

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

x+1;
x++；

MAX宏可以证明具有副作⽤的参数所引起的问题

#difine MAX(a,b) ((a) > (b) ? (a) : (b))
...
x=5;
y=8;
z=MAX(a++,b++)
printf("%d,%d,%d\n",x,y,z);

得知道预处理器处理之后的结果是什么

z = ((x++) > (y++) ? （x++）: (y++))

所以输出的结果是：x=6 y=10 z=9

4.宏替换的规则

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

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

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

5.宏和函数的对比

宏通常被应用于执行简单的运算。

比如在两个数中找出较大的⼀个时，写成下面的宏，更有优势⼀些

在这里插入代码片

为什么不用函数来完成这个任务

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

和函数相比宏的劣势：

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

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

在这里插入代码片

宏和函数对比表格

在这里插入图片描述

6.#undef

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

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

7.#和##

7.1#运算符

#运算符将宏的⼀个参数转换为字符串字面量。
它仅允许出现在带参数的宏的替换列表中。
#运算符所执行的操作可以理解为”字符串化“。
当我们有一个变量 int a = 10 的时候，
我们想打印出： the value of a is 10 .
就可以写：

#difine PRINT (n) printf("the value of "#n" is %d",n);

当我们按照下面的方式调用的时候：PRINT(a);
当我们把a替换到宏的体内时，
就出现了#a，⽽#a就是转换为"a"
代码就会被预处理为：

prinf("the value of""a"" is %d",n);

运行代码就能在屏幕上打印

the value of a is 10

7.2##运算符

## 可以把位于它两边的符号合成⼀个符号，
它允许宏定义从分离的⽂本⽚段创建标识符
## 被称为记号粘合

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

写一个函数求2个数的较大值的时候，
不同的数据类型就得写不同的函数

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

但是这样写起来太繁琐了，现在我们这样写代码试试

//宏定义
#define GENERIC_MAX(type)      \
type type##_max(type x, type y)\
{                              \
	return (x>y?x:y);         \
}

使用宏，定义不同函数

GENERIC_MAX(int)
//替换到宏体内后int##_max ⽣成了新的符号 int_max做函数名
GENERIC_MAX(float)
//替换到宏体内后float##_max ⽣成了新的符号 float_max做函数名
int main()
{
//调⽤函数
	int m = int_max(2, 3);
	printf("%d\n", m);
	float fm = float_max(3.5f, 4.5f);
	printf("%f\n", fm);
	return 0;
}

输出：

3
4.500000

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

8.命名约定

⼀般来讲函数和宏的使用语法很相似
所以语⾔本⾝没法帮我们区分二者。
那我们平时的一个习惯是：
把宏名全部大写
函数名不要全部大写

9.头文件的包含

9.1头文件被包含的方式：

9.1.1本地文件包含

#include "filename"

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

Linux环境的标准头文件的路径

/usr/include

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

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

注意按照自己的安装路径去找。

9.1.2库文件包含

#include <filename.h>

查找头文件直接去标准路径下去查找，如果找不到就提提示编译错误
对于库⽂件也可以使⽤ “ ” 的形式包含？答案是肯定的
可以，但是这样做查找的效率就低些，
当然这样也不容易区分是库文件还是本地文件了

9.2嵌套文件包含

#include 指令可以使另外一个文件被编译
这种替换的方式很简单：
预处理器先删除这条指令，并用包含文件的内容替换
⼀个头⽂件被包含10次，那就实际被编译10次，
如果重复包含，对编译的压力就比较大
test.c

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

test.h

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

如果直接这样写，test.c文件中将test.h包含5次，
那么test.h文件的内容将会被拷贝5份在test.c中。
如果test.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” 有什么区别?

10.条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）
编译或者放弃是很方便的，因为可以用条件编译
比如：调试性的代码，删除可惜，保留又碍事，
所以我们可以选择性的编译

#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__
//..
#endif

2.多个分⽀的条件编译
#if 常量表达式
//...
#elif 常量表达式
//...
#else
//...
#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

11.命令行定义

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

12.其他预处理指令

#error
#pragma
#line
...
不做介绍，⾃⼰去了解。
#pragma pack()在结构体部分介绍。

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

总结

今天学习预处理的有关知识包括：预处理符号，#define,#undef,宏的有关知识（宏参数，宏替换），宏和函数对比，#运算符和##运算符，命名约定，头文件的包含（嵌套文件的包含），条件编译，命令行定义等等

对预处理相关知识的分享就到这里了，如果感觉不错，希望可以给博主点个赞或者关注，感谢大家的支持，成为我继续分享的动力，还有什么问题和建议可以在评论区评论，拜拜。
在这里插入图片描述

吃于没块梓
关注
专栏目录
C语言-预处理详解
linkang007的博客
05-29 2103
C语言-预处理详解
数据预处理
11-28
数据预处理（datapreprocessi）是指在主要的处理以前对数据进行的一些处理。如对大部分地球物理面积性观测数据在进行转换或增强处理之前，首先将不规则分布的测网经过插值转换为规则网的处理，以利于计算机的运算。另外，对于一些剖面测量数据，如地震资料预处理有垂直叠加、重排、加道头、编辑、重新取样、多路编辑等。
什么是预处理
lee576的专栏
02-13 4854
所谓预处理是指，在对源程序进行编译之前，先对源程序中的预处理命令（主要指宏定义命令、文件包含命令和条件编译命令）进行处理；然后再将处理的结果，和源程序一起进行编译，以得到目标代码。
预处理
ITclody的专栏
06-30 591
IOS学习交流   1）预处理指令的概念及分类 a）基本概念 ①以"#"开头的预处理命令。如包括#include，宏定义命令#define等。在源程序中这些命令都放在函数之外，而且一般都放在源文件的前面，他们称为预处理部分。 ②所谓预处理是指在进行编译的第一遍扫描（词法扫描和语法扫描分析）之前所作的工作。预处理是C语言的一个重要功能，它由预处理程序负责完成。当对一个源文件进行编译时，系统将
C语言预处理详解
01-05
文字版！清晰度一定让你满意！关于C语言预处理不可多得的宝贝！
c语言预处理详解
05-05
【C语言预处理详解】 C语言的预处理是编译过程中的一个重要步骤，它在编译器进行词法分析和语法分析之前先对源代码进行处理。预处理指令是特殊的命令，它们以`#`开头，告诉编译器在正式编译程序之前执行特定的操作...
关于Pytorch的MNIST数据集的预处理详解
09-18
在深度学习领域，数据预处理是构建模型的关键步骤，它能显著影响模型的性能和训练速度。本篇文章主要探讨了如何使用PyTorch对MNIST数据集进行预处理，以提高卷积神经网络（CNN）的性能。MNIST数据集是手写数字识别的...
预处理命令
张熠彤的编程博客
03-28 919
预处理命令重点：        午餐宏定义和有参宏定义；        文件包含；        条件编译。一、宏定义        C语言标准允许在程序中用一个标识符来表示字符串，称为宏。标识符为宏名，在编译预处理时，将程序中所有的宏名用相应的字符串来替换，这个过程称为宏替换，宏分为两种：无参数宏和有参数宏。            1.无参数宏                        无参...
c::预处理
Super的博客
10-18 643
【预处理】 预处理语句是一些行首以＃开始的特殊语句，例如：＃include，＃define等就是预处理语句。在编译程序的编译过程中，进行其它编译处理(词法分析、语法分析、代码生成、优化和连接等)之前，先进行这些语句的分析处理。预处理语句使用的目的在于帮助程序员编写出易读、易改、易移植并便于调试的程序。预处理语句主要有三种：宏定义和宏替换、文件包含、条件编译。，宏包含宏常量，宏函数，条件编译。
预处理-详解
guandq2106的专栏
01-19 1451
<br /> 在将一个C源程序转换为可执行程序的过程中, 编译预处理是最初的步骤. 这一步骤是由预处理器(preprocessor)来完成的. 在源流程序被编译器处理之前, 预处理器首先对源程序中的"宏(macro)"进行处理. <br />C 初学者可能对预
预处理（2）
yooppa的博客
02-19 87
上一次是无参的宏定义；作为进阶，这次是带参的宏定义。 C语言允许宏定义带有参数。在宏定义中的参数称为形式参数，在宏调用中的参数称为实际参数。 对带参数的宏，在调用中，不仅要宏展开，而且要用实参去代换形参。 带参宏定义的一般形式： #define 宏名(形参表) 字符串 注意： 带参宏定义中，宏名和形参表之间不能有空格出现。 例如以下给出的代码， #define M(y) yy+3y 和 #define M (y) yy+3y 是不一样的，第二者会出现编译错误。 在带参宏定义中，形式参数不分配内存单
一节课教你学会【预处理详解】
最新发布
C4840的博客
09-11 945
C语言设置了一些预定义符号，可以直接使用，预定义符号也是在预处理期间处理的。__FILE__ //进⾏编译的源⽂件__LINE__ //⽂件当前的⾏号__DATE__ //⽂件被编译的⽇期__TIME__ //⽂件被编译的时间__STDC__ //如果编译器遵循ANSI C，其值为1，否则未定义1int main()return 0;//基本语法1000register//为 register这个关键字，创建⼀个简短的名字for;;//⽤更形象的符号来替换⼀种实现。
普林大数据学院数据预处理详解
"第三讲 数据预处理 - 普林大数据学院" 在数据科学领域，数据预处理是至关重要的步骤，它确保了后续分析和建模的准确性和可靠性。本讲主要围绕数据预处理展开，内容包括数据概述、数据预处理和案例分析与总结。 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值