C语言——预处理详解(#define用法+注意事项）

#define

语法规定

#define定义标识符

    语法: #define name stuff

#define例子 

#include<stdio.h>
#define A 100
#define STR "abc"
#define FOR for(;;)int main()
{printf("%d\n", A);printf("%s\n", STR);FOR;return 0;
}

 运行结果

在预处理阶段 A被替换成了100 

STR被替换成了abc

FOR替换了for(;;);死循环——因此在运行窗口一直出现_

 因为在VS2019看不见预处理阶段，我用Xshell——linux底层来观察预处理阶段的宏替换

我们知道C语言编译链接有预处理——编译——汇编——链接 4个阶段

 预处理一般干的事情有——头文件展开 去注释 宏替换 条件编译

在写switch语句经常忘记写break 我们就可以使用宏定义把case break缩写成case在预处理阶段自动帮我们加break语句

#include<stdio.h>
#define CASE break;caseint main()
{int x = 0;scanf("%d", &x);switch (x){CASE 1:printf("xxx");CASE 2:printf("yyyy");CASE 3:printf("zzz");}return 0;
}

#define玩法还有很多 自己发挥想象 在合适的场景都可以随机应变的去使用它。

 在define定义标识符的时候最后应该加不加上;？

一般我们是不建议在语句最后加上分号的，因为这样会容易导致出现问题

比如

不能在宏替换后面加分号，因为在预处理阶替换时会出现语法错误 y=100;;

两个分号会变成两条语句 else不知道与谁匹配

#define定义宏 

语法规定

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

#define name( parament-list ) stuff

比如

 

注意事项

参数列表的左括号必须与name紧邻。#define MAX(x,y) 不能是#define MAX（x,y)

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

出现编译报错

当我宏定义求最大数时，给每个参数都加了个括号 这样有必要吗？

答案是非常有必要的！因为在有些情况不加括号会出现预期之外的结果

比如

我们想要的结果是7的平方 49 

 

但结果却是17 这是为什么呢?

问题所在 因为*的优先级高于+，因此先执行2*5=10 10+5+2=17

这就体现了加括号的重要性

加括号

因此为了更好的保证在预处理阶段#define替换的准确性——给每个参数和整个参数加上括号 

#define 替换规则

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

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

#和##

如何把参数插入到字符串中？

我们发现字符串有自动连接的特点。

当我们想把一个变量名字+值打印出来了 但每次需要我们需要手动替换

那有没有一种办法变量字符名加到字符串中去呢？

这里只有当字符串作为宏参数的时候才可以把字符串放在字符串中。

format是输出格式 这样什么类型的值都可以输出了 

##作用

##可以把位于它两边的符号合成一个符号。

它允许宏定义从分离的文本片段创建标识符 。

带有副作用的宏参数 

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

x+1 y+2 不具有副作用

x++ y++ 具有副作用

++分为前置++和后置++

前置++是先++再使用 后置++是先使用再++

比如

x，y，c结果是多少？

结果是x=8 y=11 c=10 

因此定义宏时候尽量不使用带有副作用的宏参数

宏和函数对比 

宏通常被应用于执行简单的运算
比如在两个数中找出较大的一个。

最高效的其实是宏定义的MAX效率高，为什么呢？

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

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

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

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

 Max函数的反汇编

通过反汇编可以看出，Max函数会执行一堆的汇编指令 需要建立函数栈帧空间

MAX宏定义函数的反汇编

没有那么多的汇编指令 也不需要建立函数栈帧空间 且不需要调试

宏甚至可以做到函数做不到的事情

比如 

宏参数可以出现类型 但函数是做不到的

宏是多份替换的 只要使用的宏定义的地方 都会替换成stuff所有东西

因此宏如果很大 替换的地方也多 就会增加程序的负担。 

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

命名规定

一般来讲函数的宏的使用语法很相似。

所以语言本身没法帮我们区分二者

建议：
把宏名全部大写
函数名不要全部大写

#undef

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

#undef NAME

比如

出现了编译错误 MAX未定义

命令行定义

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

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

编译指令

gcc -D 数组个数 + 文件名    D和文件名在前或者后都可以

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

VS2019演示不了，所以用gcc环境下——linux演示

条件编译

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

比如调试的代码：有些代码删除很可惜，保留又碍事，有点食之无味弃之可惜的感觉，因此我们可以选择性编译——依靠条件编译指令

常见的条件编辑指令有4种

第一种

#if 常量表达式

....

#endif

常量表达式由编译器处理求值

如果#if 后面为真就执行后面语句 为假就执行#endif后面语句

#if 后面为假 VS2019下后面语句会变灰 

我们可以看到预处理阶段 为假的语句被直接删除

第二种 多个分支的条件编译

#if  常量表达式

.....

#elif 常量表达式

.....

#else

....

#endif

第三种 判断是否被定义

#if defined(symbol)

#ifdef symbol

#if !defined(symbol)

#ifndef symbol 

只要被定义过了就会执行后面语句 不会管条件为真或假

#if defined(M) == #ifdef M 

#if !defined(M) == #ifndef M 

第四种 嵌套指令 

#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 0 ;

        #endif
#endif

 这种嵌套式在stdio.h库文件里面很多

等等有很多。 

文件包含

我们已经知道，#include 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方一样。

这种替换的方式很简单:

预处理器先删除这条指令，并用包含文件的内容替换

这样一个源文件被包含10次，那就实际被编译10次。

头文件被包含的方式：

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

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

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

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

我们先看一个例子

我们用#include包含了本地文件 但我们还没有在源文件下创立一个test.h 编译器先去源文件目录查找 再去库函数目录下再去查找都没有找到test.h文件 因此会报错。

但只要我们在VS环境标准的头文件路径下面 把test.h剪切到stdio.h库文件目录下面 可以编译成功

在你实验完成后记得删除test.h，为了保持头文件的整洁，不破坏库函数文件的使用。

那我们以后可不可以用" "用于库文件的包含

理论上的是可以的，但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。同时对编译器压力会很大，因为" "先会去源文件目录下去寻找包含的目标文件，如果没有找到 才回去库函数文件目录去寻找，库文件包含会浪费一次寻找时间，因此我们要区分库文件包含<>和本地包含" "的使用，这样编译器压力会变小。

嵌套文件的包含

comm.h和comm.c是公共模块

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

test2.c和test2.h使用了公共模块

test.c和test.h使用了test1.h和test2.h模块

最终程序就会出现两份comm.h的内容。这样就造成了文件内容的重复。

那么怎么解决呢？

条件编译

#ifndef_TEST_H

#define_TEST_H

//头文件的内容

#endif

//__TEST_H (可不写)

或者

#pragma once

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

VS头文件会自带# pragma once