继前一篇文章，我们介绍了程序的翻译和执行环境，以及程序的编译+链接，本篇文章我们来详解预处理以及宏和函数的对比
3.预处理详解
3.1 预定义符号
__FILE__ //进行编译的源文件
__LINE__ //文件当前的行号
_DATE_ //文件被编译的日期
__TIME__ //文件被编译的时间
__STDC__ //如果编译器遵循ANSI C，其值为1，否则未定义
这些预定义符号都是语言内置的。
示例：
int main() { printf("%s\n", __FILE__);//文件路径 注意这里是前后各两个_ printf("%s\n", __TIME__);//编译时间 return 0; }
运行结果：
3.2 #define
#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 MAX 100 #define STR "awei" int main() { printf("%d\n", MAX); printf("%s\n", STR); return 0; }
运行结果：
关于define定义标识符后加分号的反例：
#define MAX 100; int main() { int m = 0; if (3 > 5) m = MAX;//这里实际上等于m = 100;; //相当于在if语句后放了两个语句，而多个语句需要{} else m = -1; return 0; }
#define 定义宏
#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏（macro）或定义
宏（define macro）。
示例：
如下是求最大值的一般方法与用define定义宏的方法
//代码1 求最大值的一般方法 int Max(int x, int y) { return(x > y ? x : y); } int main() { int a = 10; int b = 20; int m = Max(a, b); printf("%d\n", m); return 0; } //代码2 define宏定义的方法 #define MAX(x,y) ((x)>(y)?(x):(y)) int main() { int a = 10; int b = 20; int m = MAX(a, b); printf("%d\n", m); return 0; }
两个代码的运行结果相同：
代码2在预处理后其实被替换为如下代码：
这就是我们前面所说的：
#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏（macro）或定义宏（define macro）。
而代码1为函数传参，是先将a、b传给x、y，再将返回值传回来。
下面是宏的申明方式：
#define name( parament-list ) stuff
如：#define MAX(x,y) (x>y?x:y)
其中的parament-list是一个由逗号隔开的符号表，它们可能出现在内容stuff中。
注意：
建议以#define空格SQUARE(x) 空格((x)*(x)) 的形式进行宏定义
参数列表的左括号必须与name紧邻。
如果两者之间有任何空白存在，参数列表就会被解释为内容stuff的一部分。
如果不按照以上建议的方式进行定义，则在实际操作中可能会出现一些错误：
//代码3 #define SQUARE(x) x*x//求平方 int main() { printf("%d\n", SQUARE(5)); return 0; } //此代码的运行结果是多少呢？
运行结果：
这个代码此时是计算出了5的平方的值，但是这样的宏并不实用
反例：
//代码3反例 #define SQUARE(x) x*x int main() { printf("%d\n", SQUARE(5+1)); return 0; }
如果是这样的参数，代码就不会如你所愿输出36，因为此时代码会被预处理为
printf("%d\n", 5+1*5+1;
根据优先级，答案自然为11了，此时我们可能做如下改进：
#define SQUARE(x) (x)*(x)
貌似这样的代码已经不会有上面的问题了，但是事实证明，这样还不够完善，看下面的定义你就知道了：
//代码4 为反例 #define DOUBLE(X) (X)+(X)//求两倍 int main() { printf("%d\n", 10 * SQUARE(6 + 1)); return 0; }
根据上面代码的认识相信你一定不会认为此代码会输出140了，很容易就可以想到问题所在
此代码实际是被预处理为：
printf("%d\n", 10 * 6 + 1 + 6 + 1);
但是如果我们以#define DOUBLE(X) ((X)+(X)) 的形式宏定义上面两种错误都可以避免，这就是好的代码风格。
所以用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中
的操作符或邻近操作符之间不可预料的相互作用。
#define 替换规则
在程序中扩展#define定义符号和宏时，需要涉及几个步骤。
- 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先
被替换。 - 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。
- 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上
述处理过程。
注意：
- 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
- 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。
- 只有当字符串作为宏参数的时候才可以把字符串放在字符串中。
示例：
#define M 10 #define MAX(x,y) ((x)>(y)?(x):(y)) #define PRINT(format,val) printf("the value is " format"\n",val)//这里的format没有加引号 int main() { int m = MAX(2 + 3, M); //根据步骤1，这里的参数M优先替换为10 // int m = ((2+3)>(10)?(2+3):(10)) //步骤2，3之后的结果 printf("hello M"); //字符串常量中的M不会被替换 PRINT("%d", a);//只有当字符串作为宏参数的时候才可以把字符串放在字符串中。 return 0; }
#和##
#的作用
使用#， 可以把一个宏参数变成对应的字符串。
如何把参数插入到字符串中？
首先我们看看这样的代码：
int main() { printf("hello world\n"); printf("hello ""world");//这里是两个字符串 }
输出结果：
我们发现字符串是有自动连接的特点的。
那我们就可以利用宏写出下面的代码来避免普通输出引起的代码冗余，而且以函数方式是难以实现的：
#define PRINT(format,val) printf("the value is " format"\n",val)//这里的format没有加引号 int main() { int a = 10; PRINT("%d", a); //printf("the value is %d\n", a);//冗余的代码方式 int b = 20; PRINT("%d",b); //printf("the value is %d\n", b);//冗余的代码方式 float f = 3.5f; PRINT("%f",f); //printf("the value is %f\n", f);//冗余的代码方式 return 0; }
我们发现只有当字符串作为宏参数的时候才可以把字符串放在字符串中。
另外：使用#， 可以把一个宏参数变成对应的字符串。
比如：
#define PRINT(format,val) printf("the value of " #val " is " format"\n",val) int main() { int a = 10; PRINT("%d", a); //printf("the value of a is %d\n", a); int b = 20; PRINT("%d",b); //printf("the value of b is %d\n", b); float f = 3.5f; PRINT("%f",f); //printf("the value of f is %f\n", f); return 0; }
代码中的#val会被预处理器处理为："val"
最终的输出的结果 是：
为方便大家对两种代码进行对比，给出如下截图：
## 的作用
##可以把位于它两边的符号合成一个符号。
它允许宏定义从分离的文本片段创建标识符。
示例：
#define CAT(A,B) A##B//将A与B合在一起 int main() { int Awei258 = 100; printf("%d\n", CAT(Awei, 258)); return 0; }
注：
这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。
带副作用的宏参数
当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能
出现危险，导致不可预测的后果。副作用就是表达式求值的时候出现的永久性效果。
例如：
#define MAX(x,y) ((x)>(y)?(x):(y)) int main() { int a = 3; int b = 4; int m = MAX(++a, ++b);//如果只看这里计算，m结果为5 //int m = ((++a) > (++b) ? (++a) : (++b));//预处理后的代码，实际上在这个过程中，一直在改变a，b的值 printf("m= %d a=%d b=%d\n", m, a, b); }
运行结果：
像上面这样 完成了某个动作时，带来了其他地方影响的代码 就可以称其为带有副作用的代码，这时就会导致一些错误的发生。
宏和函数对比
宏通常被应用于执行简单的运算。
比如在两个数中找出较大的一个。
直接上代码：
//函数 int Max(int x, int y) { return(x > y ? x : y); } //宏 #define MAX(x,y) ((x)>(y)?(x):(y)) int main() { int a = 10; int b = 20; //函数的方式 int m1 = Max(a, b); printf("m1 = %d\n", m1); //宏的方式 int m2 = MAX(a, b); printf("m2 = %d\n", m2); return 0; }
我们发现用函数也可以实现，但为什么建议用宏来实现呢？
宏的优点：
- 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。
所以宏比函数在程序的规模和速度方面更胜一筹。 - 更为重要的是函数的参数必须声明为特定的类型。
所以函数只能在类型合适的表达式上使用。反之这个宏则可以适用于整形、长整型、浮点型等可以
用于>来比较的类型。
宏是类型无关的。
当然宏也是有缺点的：
宏的缺点：
- 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序
的长度。 - 宏是没法调试的。
- 宏由于类型无关，也就不够严谨。
- 宏可能会带来运算符优先级的问题，导致程容易出现错。
注意：
宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。如下面代码：
#define MALLOC(num,type) (type*)malloc(num*sizeof(type)) int main() { //int*p = (int*)malloc(10*sizeof(int)); int* p2 = MALLOC(10, int);//类型作为参数 return 0; }
为了方便大家查看，给出下表
宏和函数对比表
| 属 性 |
#define定义宏 | 函数 |
| 代 码 长 度 |
每次使用时，宏代码都会被插入到程序中。除了非常 小的宏之外，程序的长度会大幅度增长 |
函数代码只出现于一个地方；每 次使用这个函数时，都调用那个 地方的同一份代码 |
| 执 行 速 度 |
更快 | 存在函数的调用和返回的额外开 销，所以相对慢一些 |
| 操 作 符 优 先 级 |
宏参数的求值是在所有周围表达式的上下文环境里， 除非加上括号，否则邻近操作符的优先级可能会产生 不可预料的后果，所以建议宏在书写的时候多些括 号。 |
函数参数只在函数调用的时候求 值一次，它的结果值传递给函 数。表达式的求值结果更容易预 测。 |
| 带 有 副 作 用 的 参 数 |
参数可能被替换到宏体中的多个位置，所以带有副作 用的参数求值可能会产生不可预料的结果。 |
函数参数只在传参的时候求值一 次，结果更容易控制。 |
| 参 数 类 型 |
宏的参数与类型无关，只要对参数的操作是合法的， 它就可以使用于任何参数类型。 |
函数的参数是与类型有关的，如 果参数的类型不同，就需要不同 的函数，即使他们执行的任务是 相同的。 |
| 调 试 |
宏是不方便调试的 | 函数是可以逐语句调试的 |
| 递 归 |
宏是不能递归的 | 函数是可以递归的 |
命名规范
一般来讲函数和宏的使用语法很相似。所以语言本身没法帮我们区分二者。
那我们平时的一个习惯是：
**把宏名全部大写 **：MAX
函数名不要全部大写 ：Max
3.3 #undef 移除宏定义
这条指令用于移除一个宏定义。
#undef NAME //如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除。
3.4 命令行定义
许多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
3.5 条件编译
在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件
编译指令。
比如说：
调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。满足条件编译，不满足条件不编译
#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; }
如上#ifdef和#endif就是一组条件编译指令，如果#ifdef后面的定义存在，就继续执行；
当我们将#define__DEBUG__注释掉时，#ifdef后面的定义不存在，就执行#endif后面的内容：
常见的条件编译指令：
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
一般在跨平台时多用。
3.6 文件包含
我们已经知道，#include 指令可以使另外一个文件被编译。就像它实际出现于#include指令的地方
一样。
这种替换的方式很简单：
预处理器先删除这条指令，并用包含文件的内容替换。
这样一个源文件被包含10次，那就实际被编译10次。
头文件被包含的方式：
- 本地文件包含
#include "filename"
查找策略：先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标
准位置查找头文件。
如果找不到就提示编译错误。
Linux环境的标准头文件的路径：
/usr/include
VS环境的标准头文件的路径：
C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include //这是VS2013的默认路径
注意按照自己的安装路径去找。
- 库文件包含
#include <filename.h>
查找策略：查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。
这样是不是可以说，对于库文件也可以使用“”的形式包含？
答案是肯定的，可以。
但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。
嵌套文件包含
如果出现这样的场景：
comm.h和comm.c是公共模块。
test1.h和test1.c使用了公共模块。
test2.h和test2.c使用了公共模块。
test.h和test.c使用了test1模块和test2模块。
这样最终程序中就会出现两份comm.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"有什么区别? 查找策略不同
4.其他预处理指令
#error #pragma #line ... 不做介绍，自己去了解。
其他预处理指令，我们这里不会做介绍，如果有学习需要可以《C语言深度解剖》学习。
结语：
这里我们关于前半部分的内容就介绍完了，后半部分马上会更
文章中某些内容我们之前有介绍，所以只是一笔带过，还请谅解。
希望以上内容对大家有所帮助👀，如有不足望指出🙏
前路漫漫！努力变强💪💪 吧！！
