预处理详解

最新推荐文章于 2024-07-17 17:16:42 发布
最新推荐文章于 2024-07-17 17:16:42 发布
阅读量1.2k 收藏 22
点赞数 24
分类专栏： C语言的学习 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaa114514aaaa/article/details/138173746
版权

预处理详解

1.预定义符号

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

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

举个例子：

int main()
{
	printf("%s\n", __FILE__);
	printf("%s\n", __DATE__);
	printf("%s\n", __TIME__);
	printf("%d\n", __LINE__);
	// printf("%d\n", __STDC__);// err 说明VS2022的环境中是不完全支持ANSI C

	return 0;
}

下图是上述代码的打印结果

image-20240415104433561

并且这些预定义符号在预处理的时候就会被替换掉

image-20240415104625924

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

这些用#define定义的常量 和 符号 和一串代码

在预处理的时候 都会被替换掉

并且# define 语句会被编译器删掉

我们来思考一下 #define 定义常量的时候 需不需要在后面加上一个;

#define MAX 1000;
int main()
{
	int a = MAX;
	printf("%d\n", MAX); // 这里编译器已经直接发现错误了

	return 0;
}

实际上在预处理的.i文件中是这样的

image-20240415110502292

因此实际上我们不会在#define 定义常量 这句代码后面加 ;

3.#define定义宏

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

下面是宏的申明方式：

#define name( parament-list ) stuff

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

注意：

参数列表的左括号必须与name紧邻。

如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分

如：

#define SQUARE( x ) x * x

我们来看一个代码：

// 实现一个宏-计算一个数的平方
#define SQUARE(x) x*x // SQUARE(x)里边的x 会被替换成 x*x
int main()
{
	int a = 5;
	int ret = SQUARE(a);
	// 经过预处理之后
	// int ret = a*a;
	printf("%d\n", ret);

	return 0;
}

其实上述代码有点小问题：

// 上面定义的宏 也是有一些问题的
#define SQUARE(x) x*x 
int main()
{
	int a = 5;
	int ret = SQUARE(a + 1);
	// 经过替换之后 代码是  
	// int ret = a + 1 * a + 1;
	// 我们想要的是 6 * 6 但是实际上是 5 + 5 + 1
	// 如果我们想要的是6 * 6 那么就需要
	// #define SQUARE(x) ((x)*(x))  这样就是 6 * 6
	printf("%d\n", ret); // 11

	return 0;
}

我们再来看一个宏定义：

这个宏我们没有给替换的整体加上一个大括号

#define DOUBLE(x) (x) + (x)

这个宏会出现新的错误

int a = 5;
printf("%d\n",10 * DOUBLE(a)); // 55
// 我们想打印出的结果是100 实际上是55

解决这个错误只需要 在宏定义表达式两边加上一对括号就行了

# define DOUBLE(x) ((x) + (x))

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

一个宏的练习：
# include<stdio.h>
//写一个宏，可以将一个整数的二进制位的奇数位和偶数位交换

#define SWAPBIT(n) (((n) & 0x55555555) << 1 | ((n) & 0xaaaaaaaa) >> 1)
/*
((n) & 0x55555555)的意思是  让传进来的n去 & 上 55555555的二进制  这样就可以保留下来奇数位
((n) & 0xaaaaaaaa)的意思是  让传进来的n去 & 上 aaaaaaaa（这里的a是16进制）的二进制  这样就可以保留下来偶数位
如何让奇数位和偶数位交换呢
((n) & 0x55555555) << 1 意思是让奇数位左移一位 那就变成偶数位
((n) & 0xaaaaaaaa) >> 1 意思是让偶数位右移一位 那就变成奇数位
最后我们需要把奇数位和偶数位合并  那要怎么合并呢 或就可以了 也就是 |
不管是奇数位还是偶数位 只要出现1 就保留下来 这样就实现了合并
(((n) & 0x55555555) << 1 | ((n) & 0xaaaaaaaa) >> 1) 的意思就是让奇数位和偶数位合并 算出最终交换完成的二进制
*/

int main()
{
	printf("%d\n", SWAPBIT(7));
	return 0;
}

image-20240416123342530

4.带有副作用的宏参数

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

例如：

x+1;//不带副作用
x++;//带有副作用

因为x++会导致x本身发生变化 x + 1不会导致x发生变化

我们说这个x++中 让x发生变化就是副作用

比如：

int main()
{
	int a = 1;
	int b = 10;
	a = b + 1; // a=11,b=10
	a = ++b;// a = 11, b=11
	// 我们说 ++b带有副作用 在完成了让a=11的同时，也让b发生了变化
}

我们来看一个 宏参数有无副作用的影响的代码：

// 写一个宏，求两个数的较大值
#define MAX(X,Y) ((X)>(Y)?(X):(Y))
int main()
{
	int a = 3;
	int b = 4;
	// 这里传入的参数是没有问题的
	int m = MAX(a, b);
	printf("a = %d\n", a);// 3
	printf("b = %d\n", b);// 4
	printf("较大值：%d\n", m);// 4

	// 那如果我们传入一个带有副作用的参数给宏呢
	m = MAX(a++, b++);
	// 这个宏经过预处理替换过后是
	// m = ((a++) > (b++) ? (a++): (b++))
	// m = ((3++) > (4++) ? (4++) : (5++))
	// m = 5   a = 4   b = 6  
	// 因为执行了一次 a++ 两次b++ 
 	printf("a = %d\n", a);// 4
	printf("b = %d\n", b);// 6
	printf("较大值：%d\n", m);// 5
	return 0;
}

因此带有副作用的宏参数是非常危险的，因为它并不是算好了才传进去的

而是在预处理的时候直接进行替换

5.宏替换的规则

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

  1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。

  2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。

  3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

比如：

image-20240415123802877

对于MAX(a, MAX(2, M)); 来说就是先替换M 在替换MAX（2，10）

最后替换MAX（a，MAX（2，10））

注意：

  1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。

  2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

比如：

image-20240415124036983

printf(“M = %d\n”，m); 这里的M在" "里边

属于字符串的范围 ， 那么这里的M在预处理的时候就不会被替换

6.宏和函数的对比

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

比如在两个数中找出较大的一个

#define MAX(X,Y) ((X)>(Y)?(X):(Y))

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

原因有二：

  1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。

所以宏比函数在程序的规模和速度方面更胜一筹。

  1. 更为重要的是函数的参数必须声明为特定的类型。

所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以用于>来比较的类型。

宏和类型无关的。

**宏的缺点：**当然和函数相比宏也有劣势的地方：

  1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。

  2. 宏是没法调试的。

  3. 宏由于和类型无关，也就不够严谨

  4. 宏可能会带来运算符优先级的问题， 导致容易出现问题

我们来看一个宏 和 函数对比的例子

//  宏和函数的对比
// 要求：找出两个数字之间的较大值

#define MAX(a,b) ((a) > (b)? (a):(b))
// 宏的参数 是和类型无关的 这个a b都是没有类型限制的

int Max(int x, int y) // x y只能处理整型
{
	return x > y ? x : y;
}

int main()
{
	int m1 = MAX(3, -6);
	// 预处理过后   m1 = ((3) > (-6)? (3):(-6))
	int m2 = Max(3, -6);

	printf("m1 = %d\n", m1);// 3
	printf("m2 = %d\n", m2);// 3

	return 0;
}

image-20240415152250457

可以看到 函数甚至还没开始调用 用的汇编指令就已经比宏多了

image-20240415152418796

image-20240415152431777

我们可以看到 占据计算的指令 只占函数的指令的3分之一左右

这样就是我们前面提到的：

用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多

但是如果我们的计算的指令非常复杂 这个时候占据计算的指令会非常多，这个时候我们就用函数

前面我们提到宏的参数 是和类型无关的

有些时候宏可以做到函数做不到的事情

如：

//  宏可以做到函数做不到的事情
#define Malloc(n,type) (type*)malloc(n * sizeof(type))
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	// 如果我们觉得上面这样写太麻烦  我们想自己搞一个
	int* ptr = Malloc(10, int);// 这个意思就是我想创建10个int类型大小空间
	// 但是函数是无法传入一个类型作为参数的 因此这里只有宏能实现
	// 经过预处理后 这里的代码是
	// int * ptr = (int*)malloc(10 * sizeof(int));
	return 0;
}

说了这么多 我们来给宏和函数的对比做个表格来总结一下

image-20240415154437565

在后续学习c++的时候我们会学到

image-20240415160101202

7.#和##

7.1#运算符

在讲述#运算符之前 我们先来看一段代码：

printf("hello" "world\n");// helloworld
printf("helloworld\n");// helloworld

从上面代码我们可以看出C语言对字符串有着自动连接的功能

#运算符将宏的一个参数转换为字符串字面量。

它仅允许出现在带参数的宏的替换列表中

#运算符所执行的操作可以理解为”字符串化”

当我们有一个变量int a = 10;的时候，我们想打印出: the value of a is 10

就可以写：

	int a = 1;
	printf("the value of a is %d\n", a);

如果我们有多个需要写的：

	int a = 1;
	printf("the value of a is %d\n", a);
	Print(a, "%d");

	int b = 10;
	printf("the value of b is %d\n", b);	


	float f = 5.6f;
	printf("the value of f is %f\n", f);


// 我们发现上面三段代码的功能都非常相似 为了使代码看起来更加简洁 我们会想到要用函数
// 但是其实函数是做不到的 因为类型无法作为函数的参数
// 那我们就可以考虑 宏 来实现

那么通过宏实现的代码如下：

// #运算符
#define Print(n, format) printf("the value of " #n " is " format "\n", n)
// 这里的#n就是把传进来的n直接给字符串化了 相当于 "n"  ，再把n替换成传进来的参数
// 再配合上字符串自动连接 就可以拼成一个完整的字符串

int main()
{
	int a = 1;
	printf("the value of a is %d\n", a);
	Print(a, "%d");
	// 预处理之后 printf("the value of a is %d\n", a);

	int b = 10;
	printf("the value of b is %d\n", b);	
	Print(b, "%d");

	float f = 5.6f;
	printf("the value of f is %f\n", f);
	Print(f, "%f");
	// 我们发现上面三段代码的功能都非常相似 为了使代码看起来更加简洁 我们会想到要用函数
	// 但是其实函数是做不到的 因为类型无法作为函数的参数
	// 那我们就可以考虑 宏 来实现
	return 0;
}

7.2##运算符

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

被称为记号粘合这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。

这里我们想想，写一个函数求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);// 这个代码经过预处理之后是什么样子的呢
 相当于
//int int_max(int x, int y)\  // 这里的int_max函数名是由type##_max才能实现的 ##会将左右两边的符号合成一个符号并变成一个标识符
//{\
//	return x > y ? x : y;\
//}

// 定义函数
GENERIC_MAX(int);// int_max 函数
GENERIC_MAX(float);// float_max函数
// 这里就相当于创建了两个函数
int main()
{
	int r1 = int_max(3, 5);
	printf("%d\n", r1);

	float r2 = float_max(3.1f, 3.5f);
	printf("%f\n", r2);

	return 0;
}

如果我们想看看是否真的是这样

那我们也可以打开.i文件 去查看预处理过后的代码是什么样子的

如图：

image-20240415180544801

当然了 这个代码的优点和缺点也是和我们前面的总结的一样

适用于批量的定义函数 并且难以调试等等…

8.命名约定

一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者。

那我们平时的一个习惯是：

  1. 把宏名全部大写
  2. 函数名不要全部大写

当然这个并不是绝对的

比如：

offsetof

这就是一个全小写的宏

它是用来计算结构体成员相较于结构体起始位置的偏移量

9.#undef

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

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

比如：

// #undef 的使用
#define M 100

int main()
{
	printf("%d\n", M);
#undef M
	printf("%d\n", M); // 这里就会报错 因为之前#define定义的常量已经被取消了

	return 0;
}

10.命名行定义

许多C 的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。

例如：当我们根据同一个源文件要编译出一个程序的不同版本的时候，这个特性有点用处。（假定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器内存大些，我们需要一个数组能够大些。）

比如我们看下面这个代码：

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

我们在编译的时候才给SZ定义常量（注意VS是无法实现的）

下图用的是gcc

如下图：

image-20240415184209560

在图中我们在编译的时候 给SZ赋值了100和25

并运行 分别打印了1~100 和 1~25

11.条件编译(4种)

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件编译指令

意思其实就是满足条件 条件为真 那我就编译

条件为假 那就不编译

比如：

调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。

// 条件编译
#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__ //  __DEBUG__是我们定义的条件 如果为真 满足就执行下面的语句 让其参与编译
		printf("%d\n", arr[i]);//为了观察数组是否赋值成功。 
		#endif //__DEBUG__  这个endif和ifdef是一对
	}

	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

我们来看一些代码实例：

1.第一种

#if 常量表达式

//…
#endif

#define M 5

int main()
{
#if M > 0 // 这里的M可以在#define定义常量 修改  这样达到了开关的效果
	printf("参与编译\n");
#endif

	return 0;
}

image-20240415212913488

上述条件编译指令在 .i 文件当中都会消失

并且条件编译语句也可以实现注释的效果：

#if 0
#define M 5

int main()
{
#if M > 0 // 这里的M可以在#define定义常量 修改  这样达到了开关的效果
	printf("参与编译\n");
#endif

	return 0;
}

#endif

在编译器看来 这里就跟把全部代码注释是一样的

再来看一个代码实例：

2.第二种

多个分支的条件编译
#if 常量表达式
//…
#elif 常量表达式
//…
#else
//…
#endif

#define M 2

int main()
{
#if M == 1
	printf("1\n");
#elif M == 2
	printf("2\n");
#elif M == 3
	printf("3\n");
#else
	printf("4\n");
#endif
	return 0;
}

别看这里的代码看着挺多的， 实际上经过预处理之后 只会剩下被选择 编译的语句

比如上述代码在经过预处理之后只剩下

int main()
{
	printf("2\n");
	return 0;
}

我们接着来看：

3.第三种

判断是否被定义
#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol

#define MAX 1 // 如果这里被注释掉了 下面的defined(MAX)条件就为假

int main()
{
#if defined(MAX) // 这里只是判断了 MAX 是否被定义 定义了就为真  未被定义就为假
	printf("编译\n");
#endif
	return 0;
}

当然了这只是其中一种书写模式

我们再来看同样的逻辑 不一样的书写方式

// 我们来看看其他写法

#if 0
#define MAX 1 
int main()
{
#ifdef MAX // 一样的  这里 判断了 MAX 是否被定义 定义了就为真  未被定义就为假
	printf("编译\n");
#endif
	return 0;
}
#endif

#if 0
#define MAX 1 
int main()
{
#if !defined(MAX) // 加了个！ 那判断逻辑 反过来就行  这里 判断了 MAX 是否被定义 定义了就为假  未被定义就为真
	printf("编译\n");
#endif
	return 0;
}
#endif

#if 0
#define MAX
int main()
{
#ifndef MAX // 这里加个d 那么判断逻辑就和 ifdef相反 这里 判断了 MAX 是否被定义 定义了就为假  未被定义就为真
	printf("编译\n");
#endif
	return 0;
}
#endif

我们再来看最后一种情况：

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

来看代码实例：

//#define MAX1 1 
#define MAX2 1
//#define MIN1 1
#define MIN2 1
int main()
{
#if defined(MAX1) // 如果MAX1和MAX2都被定义了也是走这里
	#ifdef MIN1
		printf("编译\n");
	#endif
	#ifdef MIN2
		printf("编译\n");
	#endif
#elif defined(MAX2) // MAX2被定义了并且MAX1没有被定义 就走这里
	#ifdef MIN2
		printf("编译\n");
	#endif
#endif

	return 0;
}

总结：

其实当我们写的代码非常简单的时候 我们是用不上条件编译的

但是一旦我们写的代码比较复杂的时候 条件编译是非常常见的

12.头文件的包含

12.1头文件被包含的方式

12.1.1 本地文件包含
#include "filename"

如果我们使用"" 那么查找头文件的策略如下：

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

如果找不到就提示编译错误。

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

/usr/include

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

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

现在的VS和之前不太一样

现在的VS会把偏系统的头文件放在一个路径

把偏c语言语法的头文件放在另一个路径

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

12.1.2 库文件包含
#include <filename.h>

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

这样是不是可以说，对于库文件也可以使用 “” 的形式包含？

答案是肯定的，可以

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

12.2 嵌套文件包含

先来看一个图片

image-20240415225517278

假如一个头文件 被 重复引入 多次的话

结果是非常不好的


// 假如我们重复调用多次头文件
// 我们知道 引入头文件其实就是把头文件中的代码直接复制过来  
// 那么我们多次引入头文件 的话 就会造成文中代码的冗余
// 如果头文件的代码很多 那么就会造成严重的冗余
# include"add.h"
# include"add.h"
# include"add.h"
# include"add.h"
# include"add.h"

# include<stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	int c = Add(a, b);
	printf("%d\n", c); // 3

	return 0;
}

我们再来看一个例子：
假如头文件中的代码稍多

image-20240415230322805image-20240415230347887、

在预处理的时候 是真的会复制那么多次重复的代码过来的

那我们如何解决这个问题呢？

// 我们可以用预处理指令解决头文件重复调用的问题
// 预处理指令要写在头文件中

image-20240415230937332

如上图所示

现在即使重复调用多次头文件 也只会调用一次头文件了

当然

这个预处理指令只是一种写法 并且比较麻烦

我们还可以使用 #pragma once

#pragma once

只要有了这个预处理指令

就可以避免头文件的重复引入

注：

推荐《高质量C/C++编程指南》中附录的考试试卷（很重要）。

笔试题：

1. 头文件中的 ifndef/define/endif是干什么用的?
2. #include <filename.h> 和 #include "filename.h"有什么区别?

13.其他预处理指令

#error
#pragma
#line
...
自己了解。
#pragma pack()在结构体部分介绍。

假如一个头文件 被 重复引入 多次的话

结果是非常不好的


// 假如我们重复调用多次头文件
// 我们知道 引入头文件其实就是把头文件中的代码直接复制过来  
// 那么我们多次引入头文件 的话 就会造成文中代码的冗余
// 如果头文件的代码很多 那么就会造成严重的冗余
# include"add.h"
# include"add.h"
# include"add.h"
# include"add.h"
# include"add.h"

# include<stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	int c = Add(a, b);
	printf("%d\n", c); // 3

	return 0;
}

我们再来看一个例子：
假如头文件中的代码稍多

[外链图片转存中…(img-5mZRzf6F-1713978132997)][外链图片转存中…(img-Mk72XTox-1713978132997)]、

在预处理的时候 是真的会复制那么多次重复的代码过来的

那我们如何解决这个问题呢？

// 我们可以用预处理指令解决头文件重复调用的问题
// 预处理指令要写在头文件中

[外链图片转存中…(img-WosdulJy-1713978132997)]

如上图所示

现在即使重复调用多次头文件 也只会调用一次头文件了

当然

这个预处理指令只是一种写法 并且比较麻烦

我们还可以使用 #pragma once

#pragma once

只要有了这个预处理指令

就可以避免头文件的重复引入

注：

推荐《高质量C/C++编程指南》中附录的考试试卷（很重要）。

笔试题：

1. 头文件中的 ifndef/define/endif是干什么用的?
2. #include <filename.h> 和 #include "filename.h"有什么区别?

13.其他预处理指令

#error
#pragma
#line
...
自己了解。
#pragma pack()在结构体部分介绍。
WZF-Sang
关注
  • 24
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言预处理详解
01-05
文字版！清晰度一定让你满意！关于C语言预处理不可多得的宝贝！
c语言预处理详解
05-05
【C语言预处理详解】 C语言的预处理是编译过程中的一个重要步骤，它在编译器进行词法分析和语法分析之前先对源代码进行处理。预处理指令是特殊的命令，它们以`#`开头，告诉编译器在正式编译程序之前执行特定的操作...
关于Pytorch的MNIST数据集的预处理详解
09-18
在深度学习领域，数据预处理是构建模型的关键步骤，它能显著影响模型的性能和训练速度。本篇文章主要探讨了如何使用PyTorch对MNIST数据集进行预处理，以提高卷积神经网络（CNN）的性能。MNIST数据集是手写数字识别的...
常用C/C++预处理指令详解
09-04
C/C++预处理指令是编程过程中的一个重要环节，它们在实际编译之前对源代码进行处理，执行诸如宏替换、文件包含、条件编译等任务。预处理指令以符号“#”开头，它们不会进行语法检查，而是专注于文本替换。 1. **宏...
php_pdo 预处理语句详解
10-21
许多成熟的数据库都支持预处理语句（Prepared Statements)的概念。可以使用多种方式实现预处理，下面通过这篇文章来给大家详细的介绍下关于php_pdo预处理语句，文中通过实例代码介绍的很详细，有需要的朋友们可以...
Pandas数据结构详解.pdf
07-16
Pandas数据结构详解.pdf
你必须知道的C语言预处理的问题详解
09-05
C语言预处理是编译过程中的一个重要阶段，它在实际编译之前对源代码进行处理，主要涉及宏替换、条件编译和文件包含等功能。本文将深入探讨这些关键知识点。 首先，C语言预处理器执行宏替换，包括简单宏替换和带参数...
#pragma预处理指令详解
12-14
#pragma预处理指令详解
预处理指令详解等资料整理
01-07
预处理指令是编程过程中的重要组成部分，特别是在C和C++语言中。它们在源代码实际编译之前执行，用于修改源代码或者控制编译过程。本文主要探讨的是`#pragma`预处理指令，这是一种特殊的指令，它允许程序员针对特定...
Pandas数据预处理.png
08-01
主要是介绍了如何应用pandas预处理数据，处理数据的缺失值，异常值，对数据进行标准化，离散化，等等。
c语言的预处理大全详解
08-12
在各章节中，多次用#开头的预处理命令，如#include
ChatGPT技术的数据预处理流程详解.docx
08-16
ChatGPT 技术的数据预处理流程详解 1. 数据采集与清洗：数据采集是 ChatGPT 技术的数据预处理流程的第一步，需要大量的对话数据，可以从公开的对话语料库、聊天记录等渠道获取。在数据采集过程中，需要注意保护用户...
#pragma 预处理指令详解
05-31
#pragma 预处理指令详解
ChatGPT技术的输入数据预处理方法详解.docx
08-16
ChatGPT 技术的输入数据预处理方法详解 ChatGPT 技术作为一款基于语言生成的模型，具有出色的生成能力和语义理解能力，已经被广泛应用于对话系统、智能客服等领域。然而，在实际应用中，ChatGPT 的输入数据预处理是...
c语言编译过程详解，预处理，编译，汇编，链接
02-24
预处理展开头文件/宏替换/去掉注释/条件编译（test.imain.i）编译检查语法，生成汇编test.smain.s）汇编汇编代码转换机器码(test.omain.o)链接链接到一起生成可执行程序a.out预处理如锲子中所言，是一种展开，下表是...
ChatGPT技术的数据处理与预处理方法详解.docx
08-16
ChatGPT 技术的数据处理与预处理方法详解 ChatGPT 技术是当前人工智能领域中最具前瞻性的技术之一，它能够生成连贯且有意义的回复。然而，要让 ChatGPT 技术发挥出更好的效果，需要对数据进行处理和预处理。本文将...
ChatGPT技术使用的数据预处理流程详解.docx
08-31
ChatGPT技术的使用教程、使用方法、使用技巧、使用注意事项、使用中常见问题
【编程语言】C++和C的异同点
最新发布
无数_Mirage的博客
07-17 611
C++和C语言值得一提的异同点
普林大数据学院数据预处理详解
"第三讲 数据预处理 - 普林大数据学院" 在数据科学领域，数据预处理是至关重要的步骤，它确保了后续分析和建模的准确性和可靠性。本讲主要围绕数据预处理展开，内容包括数据概述、数据预处理和案例分析与总结。 在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值