✨个人主页： 熬夜学编程的小林

💗系列专栏： 【C语言详解】 【数据结构详解】

预处理

1、#和##

1.1 #运算符

1.2、##运算符

2、命名约定

3、#undef

4、命令行定义

5、条件编译

6、头文件的包含

6.1、头文件被包含的方式

6.1.1、本地文件包含

6.1.2、库文件包含

6.2、嵌套文件包含

7、其他预处理指令

总结

1、#和##

1.1 #运算符

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

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

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

就可以写：

<code>#define PRINT(n) printf("the value of "#n " is %d", n);

当我们按照下面的方式调用的时候：

PRINT(a);

//当我们把a替换到宏的体内时，就出现了#a，而#a就是转换为 "a" ,⼀个字符串代码就会被预处理为：

printf("the value of ""a" " is %d", a);

运行代码就能在屏幕上打印：

<code>the value of a is 10

1.2、##运算符

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

这样的连接必须产生⼀个合法的标识符。否则其结果就是未定义的。

这里我们想想，写⼀个函数求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); \

}

使用宏，定义不同函数

#include <stdio.h>

//宏定义

#define GENERAL_MAX(type) \

type type##_max(type x, type y)\

{ \

return (x>y?x:y); \

}

GENERAL_MAX(int)//函数int_max的定义

GENERAL_MAX(float)//函数float_max的定义

int main()

{

int ret1 = int_max(5, 10);

float ret2 = float_max(8.8f, 9.9f);

printf("%d %f", ret1, ret2);

return 0;

}

输出：

在实际开发过程中##使⽤的很少，很难取出非常贴切的例子。

2、命名约定

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

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

把宏名全部大写

函数名不要全部大写(第一个字母大写)

3、#undef

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

<code>#undef NAME

//如果现存的⼀个名字需要被重新定义，那么它的旧名字⾸先要被移除。

举例： 

#include <stdio.h>

#define NUM 10

int main()

{

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

#undef NUM

//printf("%d", NUM); 此处会报错，因为宏定义已经被取消了

#define NUM 20

printf("%d\n", NUM);//重新定义了名字一样的一个宏

return 0;

}

4、命令行定义

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

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

<code>#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

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;

}

常见的条件编译指令：

1.

#if 常量表达式

//...

#endif

//常量表达式由预处理器求值。

如：

#define __DEBUG__ 1

#if __DEBUG__

//..此处执行代码

#endif

//举例

#include<stdio.h>

#define M 3

int main()

{

#if M==2 //条件成立则执行下面语句

printf("hehe\n");

#endif//条件编译结束

return 0;

}

<code>2.多个分⽀的条件编译

#if 常量表达式

//...

#elif 常量表达式

//...

#else

//...

#endif

//举例

#include<stdio.h>

#define M 2

int main()

{

#if M==1

printf("hehe\n");

#elif M==2

printf("haha\n");

#elif M==3

printf("heihei\n");

#else

printf("xixi\n");

#endif

return 0;

}

<code>

3.判断是否被定义

#if defined(symbol) //定义了symbol执行

#ifdef symbol //定义了symbol执行

#if !defined(symbol)//没定义symbol执行

#ifndef symbol //没定义symbol执行

//举例

#include<stdio.h>

#define M 0

int main()

{

#if defined(M)

printf("hehe\n");

#endif

#ifdef M

printf("hehe\n");

#endif

#if !defined(M)

printf("hehe\n");

#endif

#ifndef M

printf("hehe\n");

#endif

return 0;

}

<code>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

6、头文件的包含

6.1、头文件被包含的方式

6.1.1、本地文件包含

 

#include "filename"

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

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

/usr/include

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

C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include

//这是VS2013的默认路径

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

6.1.2、库文件包含

 

#include <filename.h>

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

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

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

6.2、嵌套文件包含

我们已经知道， #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.h

void test();

struct Stu

{

int id;

char name[20];

};

如果直接这样写，test.c文件中将test.h包含5次，那么test.h文件的内容将会被拷贝5份在test.c中。如果test.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"有什么区别?

7、其他预处理指令

 

#error

#pragma

#line

...

不做介绍，自己去了解。

#pragma pack()在结构体部分介绍。

参考《C语言深度解剖》学习

总结

本篇博客就结束啦，谢谢大家的观看，如果公主少年们有好的建议可以留言喔，谢谢大家啦！