C语言之预处理详解（完结撒花）

于 2024-09-18 21:44:13 发布
阅读量251 收藏 4
点赞数 21
分类专栏： C语言学习之旅 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x_p96484685433/article/details/142305017
版权

前言

        本文为我的C语言系列的最后一篇文章，主要讲述了#define定义和宏、#和##运算符、各种条件编译指令等，希望对大家有所帮助。

❤️感谢支持，点赞关注不迷路❤️

一、预定义符号

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

  1. __FILE__ ：进行编译的源文件
  2. __LINE__：文件当前的行号
  3. __DATE__：文件被编译的日期
  4. __TIME__：文件被编译的时间
  5. __STDC__：如果编译器遵循 ANSI C ，其值为 1 ，否则未定义（VS不支持该符号）

演示：

#include <stdio.h>

int main()
{
	printf("%s\n", __FILE__);//进行编译的源文件
	printf("%d\n", __LINE__);//文件当前的行号
	printf("%s\n", __DATE__);//文件被编译的日期
	printf("%s\n", __TIME__);//文件被编译的时间

	return 0;
}

运行结果：

二、#define 定义常量

基本语法：

#define name stuff

  • name：标识符名字，记住必须是连续的，不能有空格
  • stuff：可以是数字，也可以是字符，它会在预处理阶段替换掉 name

演示：

#include <stdio.h>

#define M 100    //定义一个常量

int main()
{
	printf("%d\n", M);

	return 0;
}

运行结果：

解析：首先，该过程发生在编译与链接中的编译的预处理阶段，该过程会把定义的常量标识符直接替换成常量，如上，代码在预处理阶段就会把 M 替换成 100。

注意1：#define 定义后面不要加 分号，因为这个分号也会在预处理阶段替换掉标识符，这样就会多一个分号，导致编译报错

    

注意2：如果我们使用 #define 定义一个较长的符号时，我们需要换行时不能直接回车，而是需要用到续行符：\

如：

我们应该使用下面这种方式换行：

#define DEBUG_PRINT printf("file:%s\tline:%d\tdate:%s\ttime:%s\n" ,\
							__FILE__,\
							__LINE__,\
							__DATE__,\
							__TIME__)

切记：续行符 \ 后面要直接回车，不能有空格之类的东西。

三、#define定义宏

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

宏的声明：

#define name( parament-list ) stuff

  • name：宏的名字
  • parament-list ：参数表，传参的参数名
  • stuff：宏实现的内容

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

    

举例：使用宏实现一个平方的计算

#include <stdio.h>

//定义一个宏
#define SQUARE(x) ((x)*(x))//括号是为了保证优先级

int main()
{
	int m = 0;
	scanf("%d", &m);

	int ret = SQUARE(m);
	printf("%d\n", ret);

	return 0;
}

运行结果：

解析：简单来说，宏就是把参数替换到 stuff 里，在预处理阶段，上述 int ret = SQUARE(m); 会被替换为 int ret = ((m)*(m)); ,然后在程序运行时被计算。

    

提问：为什么要使用那么多括号？

我们看以下场景：实现一个计算2倍的宏

#include <stdio.h>

//定义一个宏，假设不使用括号
#define DOUBLE(x) x+x

int main()
{
	int ret = 10 * DOUBLE(5 + 1);

	//进过预处理阶段，会变为以下形式
	//int ret = 10 * 5+1+5+1

	printf("%d\n", ret);

	return 0;
}

运行结果：

解析：很明显这是一个错误的结果，怎么得到正确的结果呢，这就体现了括号的作用

以下为正确修改后的代码：

#include <stdio.h>

//定义一个宏，假设不使用括号
#define DOUBLE(x) ((x)+(x))

int main()
{
	int ret = 10 * DOUBLE(5 + 1);

	//进过预处理阶段，会变为以下形式
	//int ret = 10 * ((5+1)+(5+1))

	printf("%d\n", ret);

	return 0;
}

运行结果：

    

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

宏的使用与函数有点类似，但是宏是没有类型检查的，它只是完成一个替换，适用于一些简单重复的功能的实现

带有副作用的宏参数

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

什么是副作用？例如：

  1. y = x +1; // 不带副作用
  2. y = x++; // 带有副作用

以上两种方式效果相同，可是第二种会修改 x 本身的值，这就是副作用。

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

#include <stdio.h>

//定义一个比较大小的宏
#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main()
{
	int a = 10;
	int b = 20;
	int c = MAX(a++, b++);

	//经过预处理阶段后，上一条代码会变为以下形式
	//int c = ((a++) > (b++) ? (a++) : (b++));

	printf("%d\n", c);
	printf("a=%d, b=%d\n", a, b);

	return 0;
}

运行结果：

解析：因为 宏 只是完成替换，所以上述 b 的值会被修改两次，但如果是函数的话，传入相同的参数，a和b只会被修改一次，因此我们使用宏的时候需要注意这些问题

宏替换的规则

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

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

注意：

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

四、宏与函数的对比

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

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

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

函数：

int MAX(int a, int b)
{
	return 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);
	//预处理阶段上述代码会转换为以下代码：
	//int* p = (int*)malloc(10 * sizeof(int));

	return 0;
}

宏和函数的一个对比：

    

五、#和## 运算符

1.# 运算符

#运算符将宏的一个参数转换为字符串字面量。它仅允许出现在带参数的宏的替换列表中。

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

例如：我们有以下代码：

#include <stdio.h>

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

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

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

	return 0;
}

运行结果：

提问：上述用于打印 the value of a is 10 这串代码能否使用宏或者函数封装起来？

答案：使用宏可以，函数做不到。

函数为啥做不到呢？

void print(int a)
{
	printf("the value of a is % d\n", a);
}

原因：

  1. 首先函数不能打印多类型数据
  2. 其次，the value of a is 10，中的 a 是没办法替换的，我们的要求是 a 能根据参数名变化的。而函数中的 参数变量名  是跟字符没有联系的。因此函数做不到这一效果。

使用宏来实现：

首先我们需要了解 printf 的一个机制：

#include <stdio.h>

int main()
{
	printf("Hello World\n");
	printf("Hello"" World\n");

	return 0;
}

运行结果：

解析：如图和代码，printf 其实会自动拼接字符串，也就是说，printf 中有多个字符串，最终都会拼接成一条字符串输出打印。

根据 printf 的这条性质，加上 # 运算符可以把宏的一个参数转换为字符串字面量，我们就可以以下宏：

#include <stdio.h>

#define PRINT(format, n) printf("the value of "#n" is "format"\n", n) 

int main()
{
	int a = 10;
	PRINT("%d", a);
    //示例预处理之后的效果：
    //printf("the value of " "a" " is " "%d" "\n", n);

	int b = 20;
	PRINT("%d", b);

	float f = 6.6f;
	PRINT("%.1f", f);

	return 0;
}

运行结果：

2.## 运算符

## 可以把位于它两边的符号合成一个符号，它允许宏定义从分离的文本片段创建标识符。## 被称为记号粘合。这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。

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

#include <stdio.h>

int int_max(int a, int b)
{
	return a > b ? a : b;
}

float float_max(float a, float b)
{
	return a > b ? a : b;
}

int main()
{
	printf("%d\n", int_max(3, 4));
	printf("%.1f\n", float_max(5.9f, 6.1f));

	return 0;
}

运行结果：

提问：如果只用函数，那么我们每次换个类型比较，就需要重新写一个对应类型的函数，有没有什么办法简化这一过程呢？

答案：有的，使用宏结合 ##运算符 就可以制作一个函数模版，简化这一过程

#include <stdio.h>

//宏定义, type##_max预处理之后将会合成一个符号
#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)
//{
//	  return (x > y ? x : y);
//}

//定义一个比较浮点型大小的函数
GENERIC_MAX(float)

//定义一个比较字符型大小的函数
GENERIC_MAX(char)

int main()
{
	printf("%d\n", int_max(3, 4));
	printf("%.1f\n", float_max(5.9f, 6.1f));
	printf("%c\n", char_max('a', 'b'));

	return 0;
}

运行结果：

提醒：在实际开发过程中##使用的很少，很难取出非常贴切的例子。主要是让我们看到别人这样写的时候我们能够看懂。

六、命名约定

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

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

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

七、#undef

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

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

示例：

#include <stdio.h>

//定义一个常量
#define M 100

int main()
{
	printf("%d\n", M);

//移除对M的宏定义
#undef M

	printf("%d\n", M);

	return 0;
}

运行结果：

八、条件编译

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

常见的条件编译指令：

1.#if #endif

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

功能：常量表达式成立，指向 #if 与 #endif 之间的所有代码，不成立则不执行

示例：

#include <stdio.h>

//定义一个常量
#define M 2

int main()
{
//条件指令，条件成立执行与 endif 之间的代码，否则不执行
#if M == 2
	printf("hello!\n");
#endif

	return 0;
}

运行结果：

注意：一定是常量表达式，不能是自己定义的变量，可以是#define定义的常量，因为变量是在程序编译后运行时生成的，而预处理指令是在预处理阶段执行的。

因为表达式为假不执行代码，所以可以用来注释多行代码：

#if 0

#include <stdio.h>

int main()
{
	printf("hello!\n");

	return 0;
}

#endif

2.多个分支的条件编译

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

功能：效果与if   else if   else相似，只不过是在预处理阶段执行且必须是常量表达式

示例：

#include <stdio.h>

//定义一个常量
#define M 4

int main()
{
#if M == 1
	printf("1\n");
#elif M == 2
	printf("2\n");
#elif M == 3 //#elif可以有多个
	printf("3\n");
#else
	printf("%d\n", M);
#endif

	return 0;
}

运行结果：

3.判断是否被定义

这两种效果一样，下面一种是简写

#if defined(symbol)
#ifdef symbol

功能：检查 symbol 是否用 #define 定义过。

#include <stdio.h>

//定义一个常量
#define M 4

int main()
{
#ifdef M
	printf("hh\n");
#endif

	return 0;
}

运行结果：

注意：同样要与 #endif 搭配使用

判断是否被定义还有一种相反的写法：

同样也有两种写法：

#if !defined(symbol)

#ifndef symbol

功能：用法相同，效果相反，判断是否没有被定义

示例：

#include <stdio.h>

int main()
{
#ifndef M
	printf("hh\n");
#endif

	return 0;
}

运行结果：

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.头文件被包含的方式：

经常写头文件的朋友应该都知道，我们包含头文件的方式有两种，那么这两种包含方式有什么区别呢？答案：区别在于查找策略不同

1.本地文件包含

#include "filename"

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

    

2.库文件包含

#include <filename>

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

    

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

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

2.嵌套文件包含

首先我们要知道一个常识：就是如果没有任何指令的情况下，一个头文件被包含了多次，那么它就会被编译多次。也就是说如果一个头文件被包含10次，那就实际被编译10次，如果重复包含，对编译的压力就比较大。

如下：

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 文件中将 test.h 包含5次，那么 test.h 文件的内容将会被拷贝5份在test.c中。如果 test.h 文件比较大，这样预处理后代码量会剧增。如果工程比较大，有公共使用的头文件，被大家都能使用，又不做任何的处理，那么后果真的不堪设想。

虽然实际中不会这样直接包含5次，当在一些多文件情况下，我们可能不得已间接包含多次，所以如何解决呢？答案：条件编译。

每个头文件的开头写：

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

解析：#ifndef __TEST_H__ 用于判断 __TEST_H__ 是否没有被定义，如果重复包含这里就会被判断已经被定义过，那么整个头文件内容将不会执行。如果没有定义，就 #define __TEST_H__ 定义一个该名称。用于下次判断。

当然还有一个简写的方法，使用VS的经常可以看到

#pragma once

我们在VS新建头文件时，编译器就会自动添加这项指令，该指令的作用就是防止头文件被重复包含

    

当然预处理指令不止这些，有兴趣的可以参考《C语⾔深度解剖》了解更多。

    

总结

        以上就是本文的全部内容了，感谢支持。

进击的_鹏
关注
专栏目录
C语言编译预处理详解
喜欢编程，将自己会的知识分享给大家
10-23 3850
C语言由源代码生成可执行程序的过程：C源程序－>编译预处理－>编译－>优化程序－>汇编程序－>链接程序－>可执行文件其中编译预处理阶段，读取C源程序，对其中的预处理指令（以#开头的指令）和特殊符号进行处理预处理过程先于编译器对源代码进行处理，读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行转换。预处理过程还会删除程序中的注释和多余的空白字符使用#define命令并不是真正的定义符号常量，而是定义一个可以替换的宏。被定义为宏的标识符称为“宏名”。
C语言-预处理详解
linkang007的博客
05-29 2066
C语言-预处理详解
【c语言】详解C语言预处理、编译、链接
烧鸡配油茶的博客
03-15 1071
对于c语言的初学者来说，一上来就会对#include、 #define 这些预处理指令表示摸不着头脑，询问老师，老师便会回答 ：你先不用懂，这个问题先放着吧！.......那么今天终于到了要揭秘的时刻了！完结撒花！语法：ps:！！！在define定义标识符的时候，不要在最后加上;容易出问题#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏（macro）或定义 宏（define macro）。下面是宏的申明方式：其中的 parament-list 是一个由逗号隔开的符号表。
初始C语言最后一章《编译、链接与预处理详解》
熵减玩家
04-01 843
编译、链接、预处理
C语言:贪吃蛇
2302_81053095的博客
04-27 2163
​ 贪吃蛇，一种很贪吃的蛇。 贪吃蛇是一款久负盛名的游戏，它也和俄罗斯方块，扫雷等游戏位列经典游戏的行列。 接下来，我们用500行代码实现这个游戏！ ​
C语言学习－结构体
2303_79972050的博客
04-10 2050
结构体:我重生了，重生回到了刚学结构体的那一天，上一世我不可一世，以为学完C语言已天下无敌，直到遇到了}Node;数据结构（链表）， 我的天哪，我不敢了，结构体大人，我看不懂，我太不自量力了，这一次我下定决心一定要好好学习结构体。因此，我决定写下这篇博客来警醒后面的人（doge）。总之，结构体是后续学各种数据结构的基础，加油吧！前面学过一般的指针，字符指针，数组指针，函数指针。结构体指针是一种指针，这种指针变量是指向结构体的。这种指针有什么用？结构体指针变量存储结构体变量的地址。
C语言预处理详解
01-05
文字版！清晰度一定让你满意！关于C语言预处理不可多得的宝贝！
c语言中预处理都有哪些类型,c语言中预处理命令都有哪些
weixin_31411313的博客
05-22 920
匿名用户1级2017-12-21 回答我们可以在C源程序中插入传给编译程序的各中指令，这些指令被称为预处理器指令，它们扩充了程序设计的环境。现把常用的预处理命令总结如下：1. 预处理程序按照ANSI标准的定义，预处理程序应该处理以下指令：#if #ifdef #ifndef #else #elif#endif#define#undef#line#error#pragma#include显...
基于51单片机-C语言之预处理总结
07-19
C语言预处理是编译过程的一个重要步骤，在程序被编译之前，预处理器会对源代码进行处理。预处理命令都以“#”符号开始，并且位于每一行的开头。这些命令可以分为三个主要部分：宏定义、文件包含、条件处理。预处理...
C语言中的函数，实参，形参，递归
lly_b的博客
09-12 845
递归是解决问题的一种重要技术，通过函数调用自身来解决问题。递归函数必须有一个基准条件，防止无限递归。尽管递归在某些场景下代码简洁优美，但在性能和效率上可能不如迭代，特别是在处理大规模问题时需要谨慎使用。
【2025届华为秋招机考三道编程题之一】华为校招留学生软件开发工程师-真题机考笔试/(200分)- 跳格子3（Java & JS & Python & C）
Dgntsj的博客
09-12 1156
华为校招机考的题型：编程：软件测试工程师，算法，OD岗，三道编程题不限语言【C++，Python，Java】校招：600分 120分钟，100/200/300社招：400分 150分钟， 100/100/200。
二十种编程语言庆祝中秋节
敲代码别忘了喝上一杯凉白开。
09-17 1081
在全球范围内，编程语言作为技术沟通的桥梁，不仅仅局限于解决技术问题，还能承载文化传递的使命。本文展示了如何使用二十种不同的编程语言来表达对中秋节的祝福，这些语言包括了Python、C、C++、Java、C#、Perl、Go、ASP、PHP、JavaScript、HTML、Visual Basic、VB早期版本、Visual C++、Delphi、Shell、Cobol、ActionScript、Foxpro和DOS批处理。每种语言的代码示例简单直接，都以其独特的语法输出“祝大家中秋快乐”的信息。
基于大模型技术的算力产业监测服务平台设计
09-17
内容概要：本文提出了一种新型算力产业监测服务平台的设计理念，运用国内自主研发的大模型技术支持，通过对传统技术的改进和完善，提出了三层架构的设计方法，即基础设施层（含向量数据库和模型训练）、大模型应用框架层（强化数据处理与多维关系挖掘）及业务层（如智能分析助手）。这种设计方案旨在提高算力产业发展监测与决策制定的质量。 适合人群：电信行业的从业人员及研究人员；算力产业链各环节管理者；政府相关机构和政策决策者。 使用场景及目标：在多种算力相关的应用场景（如云计算中心管理，数据中心监测，政策分析）中辅助决策者进行快速有效的信息获取和技术选择；助力算力产业发展方向的精确把控和战略调整。 其他说明：随着大模型技术的日臻成熟，该算力产业监测服务平台预计将进一步丰富自身的应用领域和服务深度，以促进算力行业更智慧化发展。
This_honeypot_supports_Telnet_and_SSH_two_protocol_FF-Pot.zip
最新发布
09-17
This_honeypot_supports_Telnet_and_SSH_two_protocol_FF-Pot
吉他谱_What I've Done - Linkin Park.pdf
09-17
初级入门吉他谱 guitar tab
吉他谱_Too sweet - Hozier.pdf
09-17
初级入门吉他谱 guitar tab
Linux使用的一些笔记，包括shell命令，软件，一些实用的网站的整理_Linux_note.zip
09-17
Linux使用的一些笔记，包括shell命令，软件，一些实用的网站的整理_Linux_note
基于ssm的机房预约系统设计与实现.docx
09-17
基于ssm的机房预约系统设计与实现.docx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值