前言
本篇接前一篇【C语言篇】编译和链接以及预处理介绍（上篇）
#和##
#运算符
#运算符将宏的⼀个参数转换为字符串字⾯量。它仅允许出现在带参数的宏的替换列表中。
#运算符所执⾏的操作可以理解为“字符串化”。
在这之前我们先铺垫一个知识：
#include <stdio.h> int main() { printf("hello world\n"); printf("hello"" world\n"); return 0; }
输出结果：
hello world hello world
在C语言中两个字符串可以天然的合成一个字符串
当我们有⼀个变量 int a = 10; 的时候，我们想打印出： the value of a is 10 .
首先：函数是不能完成这一操作的
void print(int n) { printf("the value of n is %d\n", n); }
无论参数传什么，字符串里的n都不能根据变量名改变，名字只能是n
但宏可以：
#define PRINT(format, n) printf("the value of " #n " is " format"\n", n) int main() { int a = 10; PRINT("%d", a); //预处理替换后如下：#a就变成了字符串"a" //printf("the value of " "a" " is " "%d""\n", 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 = 5.5f; PRINT("%f", f); //预处理替换后如下，同理 //printf("the value of " "f" " is " "%f""\n", f); return 0; }
这样打印出来的就是：
##运算符
##可以把位于它两边的符号合成⼀个符号，它允许宏定义从分离的⽂本⽚段创建标识符。 ## 被称为记号粘合，这样的连接必须产⽣⼀个合法的标识符。否则其结果就是未定义的。
这⾥我们想想，写⼀个函数求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做函数名 #include <stdio.h> int main() { printf("%d\n", int_max(3, 5)); printf("%f\n", float_max(3.0, 5.0)); return 0; }
在预处理后替换就生成了不同的函数
命名约定
⼀般来讲函数的宏的使⽤语法很相似。所以语⾔本⾝没法帮我们区分⼆者。
那我们平时的⼀个习惯是：
把宏名全部⼤写
函数名不要全部⼤写
但是也有特例：之前我们在【C语言篇】结构体和位段详细介绍里所讲的offsetof就是一个宏，但它没有遵守这个规则，对于我们自己来说一般还是遵守这个习惯比较好
#undef
这条指令⽤于移除⼀个宏定义。
很简单，例子如下：
#define M 100 int main() { printf("%d\n", M); #undef M printf("%d\n", M);//报错 return 0; }
命令⾏定义
许多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
条件编译
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃是很⽅便的。因为我们有条件编译指令。
⽐如说：
调试性的代码，删除可惜，保留⼜碍事，所以我们可以选择性的编译。
#if和#endif
#if 常量表达式 //... #endif //常量表达式由预处理器求值 #if 1//改为0则直到#endif之内的代码不被编译 #define M 2 int main() { printf("hehe\n"); return 0; } #endif //一定要是常量表达式 int main() { int a = 2; #if a==2 //err printf("hehe"); #endif return 0; }
多个分支的条件编译
#if 常量表达式 //... #elif 常量表达式 //... #else //... #endif #define M 3//根据M的值来条件性编译 int main() { #if M==1 printf("hehe\n"); #elif M==3 printf("haha\n"); #elif M == 4 printf("heihei\n"); #else printf("呵呵\n"); #endif return 0; }
判断是否被定义
#if defined(symbol) #ifdef symbol #define ZHANGSAN 100 int main() { #if defined(ZHANGSAN)//如果ZHANGSAN被定义，就编译 printf("zhangsan\n"); #endif return 0; } //另一种写法 #define ZHANGSAN 100 int main() { #ifdef ZHANGSAN//如果ZHANGSAN被定义，就编译 printf("zhangsan\n"); #endif return 0; } //上面两种的反义写法 #if !defined(symbol) #ifndef symbol #define ZHANGSAN 100 int main() { #if !defined(ZHANGSAN)//如果ZHANGSAN未被定义，就编译 printf("zhangsan\n"); #endif return 0; } #define ZHANGSAN 100 int main() { #ifdef ZHANGSAN printf("zhangsan\n"); #endif return 0; }
嵌套指令
和if...else语句一样可以嵌套
#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
条件编译在跨平台性代码的编译中使用广泛
头文件被包含
头文件被包含的方式
本地文件包含
#include "filename"
查找策略：先在源⽂件所在⽬录下查找，如果该头⽂件未找到，编译器就像查找库函数头⽂件⼀样在标准位置查找头⽂件。
如果找不到就提⽰编译错误。
Linux环境的标准头⽂件的路径：
/usr/include
VS环境的标准头文件的包含路径：
C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include //这是VS2013的默认路径
注意按照⾃⼰的安装路径去找。
库文件的包含
#include <filename.h>
查找头⽂件直接去标准路径下去查找，如果找不到就提⽰编译错误。
这样是不是可以说，对于库⽂件也可以使⽤ “” 的形式包含？
答案是肯定的，可以，但是这样做查找的效率就低些，当然这样也不容易区分是库⽂件还是本地⽂件了。
嵌套文件包含
我们已经知道， #include 指令可以使另外⼀个⽂件被编译。就像它实际出现于 #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.c⽂件中将test.h包含5次，那么test.h⽂件的内容将会被拷⻉5份在test.c中。 如果test.h⽂件⽐较⼤，这样预处理后代码量会剧增。如果⼯程⽐较⼤，有公共使⽤的头⽂件，被⼤家都能使⽤，⼜不做任何的处理，那么后果真的不堪设想。
类似的例子如下：
当工程很大时，一个头文件很可能在不经意间被包含了多次
如何解决头⽂件被重复引⼊的问题？答案：条件编译。
每个头⽂件的开头写：
#ifndef __TEST_H__ #define __TEST_H__ //头⽂件的内容 #endif //__TEST_H__
第一次包含的时候，没有定义__TEST_H__，所以下面的头文件代码内容会参与编译，在第二次包含相同头文件时，一来先判断发现__TEST_H__已经被定义了，所以下面头文件内容就不会再参与编译了，通过这种方式让相同头文件只会被包含一次
或者：
#pragma once
在VS上当我们创建了一个头文件时，最上面都是有这一句的，这是一种比较现代的写法，很多编译器都使用这种来防止头文件的重复包含
其他预处理指令
#error #pragma #line ... #pragma pack()在结构体部分介绍了
下图出自C语言深度解剖
写在最后
在这两篇我们笼统的介绍了关于编译了链接的过程，并对编译阶段的预处理过程进行了比较深入的讲解，希望对各位读者有所帮助😘
以上就是编译和链接以及预处理介绍（下篇）内容啦，各位大佬有什么问题欢迎在评论区指正，您的支持是我创作的最大动力！❤️
