【C语言探索之旅】 第二部分第五课：预处理

内容简介

1、课程大纲
2、第二部分第五课： [b][b][b][b][b][b]预处理[/b][/b][/b][/b][/b][/b]3、第二部分第六课预告: 创建你自己的变量类型

课程大纲

我们的课程分为四大部分，每一个部分结束后都会有练习题，并会公布答案。还会带大家用C语言编写三个游戏。
C语言编程基础知识

什么是编程？

工欲善其事，必先利其器

你的第一个程序

变量的世界

运算那点事

条件表达式

循环语句

实战：第一个C语言小游戏

函数

练习题

习作：完善第一个C语言小游戏

C语言高级技术

模块化编程

进击的指针，C语言王牌

数组

字符串

预处理

创建你自己的变量类型

文件读写

动态分配

实战：“悬挂小人”游戏

练习题

习作：用自己的语言解释指针

用基于C语言的SDL库开发2D游戏

安装SDL

创建窗口和画布

显示图像

事件处理

实战：“超级玛丽推箱子”游戏

掌握时间的使用

用SDL_ttf编辑文字

用FMOD控制声音

实战：可视化的声音谱线

练习题

数据结构

链表

堆，栈和队列

哈希表

练习题

第二部分第五课：预处理

大家在一起经历了前三课： 指针，数组和字符串的“疲劳轰炸”之后，这一课回归轻松。就像刚在沙漠里行走了数日，突然看到一片绿洲，还有准备好的躺椅，清澈的小湖，冷饮，西瓜，一台电脑（又暴露了程序员的本质）等等，脑补一下这个画面还是挺开心的。

前面三课我们一下子学了不少新知识点，虽然小编没有那么善良，但也不至于不给大家小憩的机会啊。

这一课我们来聊聊“预处理器”，这个程序就在编译之前运行。

当然了，虽然这一课不难，可以作为中场休息，但不要认为这一课的内容不重要。相反，这一课的内容非常有用。

include指令

在这个系列教程最初的某一课里，我们已经向大家解释过：在源代码里面总有那么几行代码是很特别的，称之为“预处理命令”。

这些命令的特别之处就在于它们总是以#开头，所以很容易辨认。

预处理命令有好几种，我们现在只接触了一种：以#include开始的预处理命令。

#include命令可以把一个文件的内容包含到另一个文件中。

在之前的课里我们已经学习了如何用#include命令来包含头文件（以.h结尾的）。
头文件有两种，一种是C语言的标准库定义的头文件（stdio.h, stdlib.h等），另一种是用户自定义的头文件。

如果要导入C语言标准库的头文件（位于你安装的IDE的文件夹或者编译器的文件夹里），需要用到尖括号 <>。如下所示：

#include <stdio.h>

如果要导入用户自己项目中定义的头文件（位于你自己项目的文件夹里），需要用到双引号。如下所示：

#include "file.h"

事实上，预处理器在编辑之前运行，它会遍历你的源文件，寻找每一个以＃开头的预处理命令。

例如，当它遇到＃include开头的预处理命令，就会把后面跟的头文件的内容都插入到此命令处，作为替换。

假设我有一个C文件，包含我的函数的实现代码；还有一个H文件，包含函数的原型。
我们可以用下图来描绘预处理的时候发生的情况：



如上图所示，H文件的所有内容都将替换C文件的那一行预处理命令。

假设我们的C文件内容如下所示：

#include "file.h"

int myFunction(int thing, double stuff)
{
/* 函数体 */
}

void anotherFunction(int value)
{
/* 函数体 */
}

我们的H文件内容如下所示：

int myFunction(int thing, double stuff);
void anotherFunction(int value);

编辑之前，预处理器就会用H文件的内容替换那一行 #include <file.h>

经过替换之后， C文件内容如下：

int myFunction(int thing, double stuff);
void anotherFunction(int value);

int myFunction(int thing, double stuff)
{
/* 函数体 */
}

void anotherFunction(int value)
{
/* 函数体 */
}

define命令

现在我们一起来学习一个新的预处理命令，就是＃define命令。

这个命令使我们可以定义预处理常量，也就是把一个值绑定到一个名称。例如：

#define LIFE_NUMBER 7

我们必须按照以下顺序来写：

#define
要绑定数值的那个名称
数值

注意：虽然说这里的名称是大写字母（因为习惯如此，你也可以小写），但是这与我们之前学过的const变量还是很不一样。const变量的定义是像这样的：

const int LIFE_NUMBER = 7;

上面的const变量在内存中是占用空间的，虽然其不能改变，但是它确确实实储存在内存的某个地方。但是预处理常量却不是这样。

那预处理常量是怎么样运作的呢？
事实上，处理器会把由#define定义的所有的名称替换成对应的值。

如果大家使用过微软的软件Word，那应该对“查找并替换”的功能比较熟悉。我们的#define 就有点类似这个功能，它会查找当前文件的所有名称，将其替换为对应的数值。

你也许要问：“用预处理常量意义何在呢？有什么好处？”

问得好。

第一，因为预处理常量不用储存在内存里。就如我们之前所说，在编译之前，预处理常量都被替换为代码中的数值了。

第
二，预处理常量的替换会发生在所有引入#define语句的文件里。如果我们在一个函数里定义一个const变量，那么它会在内存里储存，但是如果前面不
加static关键字（关于static，请参看之前的课程）的话，它只在当前函数有效，函数执行完就被销毁了。然而预编译常量却不是这样，它可以作用于
所有函数，只要函数里有那个名称，都会替换为对应的数值。这样的机制在有些时候是非常有用的。特别对于嵌入式开发，内存比较有限，经常能看到预处理常量的
使用。

能否给出一个实际使用#define的例子？
好吧，就说一个之后我们第三部分内容：《编写C语言游戏》中经常要用到的。当你用C语言来创建一个窗口时，你需要定义窗口的宽度和高度，这时候就可以使用#define了：

#define WINDOW_WIDTH      800
#define WINDOW_HEIGHT    600

看到使用预处理常量的好处了么？之后如果你要修改窗口的宽度和高度，不必到代码里去改每一个值，只需要在定义处修改就好了，非常节省时间。

注意：通常来说，#define语句放在.h头文件中，和函数原型那些家伙在一起。如果有兴趣，大家可以去看一下标准库的.h文件，例如stdio.h，你可以看到有不少#define语句。

用于数组大小（维度）的#define
我们在C语言编程中也可以使用预处理常量（#define语句定义）来定义数组的大小。例如：

#define  MAX_DIMENSION   2000

int main(int argc, char *argv[])
{
char string1[MAX_DIMENSION], string2[MAX_DIMENSION];
// ...
}

你也许会问：“但是，不是说我们不能在函数的中括号中放变量，甚至是const变量也不可以吗？”
对，但是MAX_DIMENSION并不是一个变量，也不是一个const变量啊！就如之前说的，预处理器会在编译之前把以上代码替换为如下：

int main(int argc, char *argv[])
{
char string1[2000], string2[2000];
// ...
}

这样有一个好处，就如之前所说，如果将来你觉得你的数组大小要修改，可以直接修改MAX_DIMENSION的数值，非常便捷。

在#define中的计算我们还可以在定义预处理常量时（#define语句中）做一些计算。
例如，以下代码首先定义了两个预处理常量WINDOW_HEIGHT和WINDOW_WIDTH，接着我们可以利用这两个预处理常量来定义第三个预处理常量： PIXEL_NUMBER（意思是 像素数目，等于 窗口宽度 x 窗口高度），如下：

#define WINDOW_WIDTH    800
#define WINDOW_HEIGHT  600
#define PIXEL_NUMBER    (WINDOW_WIDTH * WINDOW_HEIGHT)

在编译之前，PIXEL_NUMBER会被替换为，800 x 600 = 480000

当然预处理常量对于基本的运算：+，-，*，/和%都是支持的。

注意：用#define定义预处理常量时要尽量多用括号括起来，不然会出现意想不到的结果，因为预处理常量只是简单的替换。

系统预先定义好的预处理常量
我们自己可以定义很多预处理常量，C语言系统也为我们预先定义了几个有用的预处理常量。

这些C语言预定义的预处理常量一般都以两个下划线开始，两个下划线结束，例如：

__LINE__ ： 当前行号
__FILE__ ： 当前文件名
__DATE__ ： 编译时的日期
__TIME__ ： 编译时的时刻

这些预处理常量对于标明出错的地方和调试是很有用的，用法如下：

printf("错误在文件 %s 的第 %d 行\n", __FILE__, __LINE__);
printf("此文件在 %s %s 被编译\n", __DATE__, __TIME__);

输出如下：

错误在文件 main.c 的第 10 行
此文件在 Mar 25 2015 09:11:01 被编译

不带数值的#define
我们也可以像如下这样定义预处理常量：

#define  CONSTANT

很奇怪吧，后面竟然没有对应的数值。

以上语句用于告诉预处理器：CONSTANT这个预处理常量已经定义了，仅此而已。虽然它没有对应的数值，但是它“存在”（想起了邓紫棋唱的那首《存在》）。

你也许要问：“这样有什么意义呢？”
这样做的用处暂时还不明显，但是我们在这一课里马上会学到。

宏
我们现在知道用#define语句可以把一个数值绑定到一个名称上。然后在预处理阶段（编译之前）预处理器就可以在代码里用数值替换所有的预处理常量了，非常方便。例如：

#define NUMBER 10

意味着接下来你的代码里所有的NUMBER都会被替换为10。是简单的“查找-替换”。

但是#define预处理命令还可以做更厉害的事，果然是Bigger than bigger么？

#define还可以用来替换…一整个代码体。当我们用#define来定义一个预处理常量，这个预处理常量的值是一段代码的时候，我们说我们创建了一个“宏”。

“宏”，英语是macro。一开始可能不太好理解。这是一个编程术语。台湾一般翻成“巨量”。可以说是一种抽象，但在C语言里就只用于简单的“查找-替换”。

趣事：之前某网站出现一个词：“王力巨集”，原来这个网站在做简体中文到繁体中文转换时，把“王力宏”中的那个“宏”替换为了“巨集”，我们的力宏就这么“躺枪”了……

没有参数的宏
下面给出一个很简单的宏的定义：

#define HELLO()  printf("Hello\n");

可以看到，与之前的预处理常量不太一样的是：名称后多了一对括号，我们马上就来看这有什么用处。

我们用一段代码来测试一下：

#include <stdio.h>

#define HELLO()  printf("Hello\n");

int main(int argc, char *argv[]){
HELLO()

return 0;
}

运行输出：

Hello

是不是有点意思，不过暂时还不是那么新颖。
需要理解的是： 宏不过是在编译之前的一些代码的简单替换。

上面的代码在编译前会被替换为如下：

int main(int argc, char *argv[])
{
printf("Hello\n");
return 0;
}

如果你理解了这个，那对于宏的基本概念也差不多理解了。

你也许会问：“那我们每一个宏只能写在一行上么？”

不是的，只需要在每一行的结尾写上一个\（反斜杠），就可以开始写新的一行了，而预处理器是把这些行看成一行的，可以说\起到了链接的作用。例如：

#include <stdio.h>

#define PRESENT_YOURSELF() printf("您好, 我叫Oscar\n"); \
printf("我住在法国小城Antibes\n"); \
printf("我喜欢游泳\n");

int main(int argc, char *argv[]){
PRESENT_YOURSELF()

return 0;
}

运行输出：

您好，我叫Oscar
我住在法国小城Antibes
我喜欢游泳

我们注意到了，调用宏的时候，在末尾是没有分号的。事实上，因为

PRESENT_YOURSELF()

这一行是给预处理器来处理的，所以没必要以分号结尾。

有参数的宏
我们刚学习了无参的宏，也就是括号里没有带参数的宏。这样的宏有一个好处就是可以使代码里经常出现的较长的代码段变得短一些，看起来简洁。
但是，宏带了参数才真正变得有趣起来。

#include <stdio.h>

#define MATURE(age) if (age >= 18) \
printf("你成年了\n");

int main(int argc, char *argv[])
{
MATURE(25)

return 0;
}

运行输出：

你成年了

这样是不是就有点像函数了？就是这么酷炫。

上面的宏是怎么运作的呢？

age这个参数在实际调用宏的时候，会被替换为括号里的数值，这里是25，所以，整个宏就替换为了：

if (25 >= 18)
printf("你成年了\n");

不就是我们熟悉的老朋友： if语句么。

上面的宏定义中，我们也可以用一个else来处理“你还未成年”的条件，自己动手试一下吧，不难。

当然我们也可以创建带多个参数的宏，例如：

#include <stdio.h>

#define MATURE(age, name) if (age >= 18) \
printf("你已经成年了， %s\n", name);

int main(int argc, char *argv[])
{
MATURE(27, "Oscar")

return 0;
}

运行输出：

你已经成年了，Oscar

好了，对于宏我们需要了解的也差不多介绍完了，如果使用得当，宏是相当有用的，但是有些时候，滥用宏也会产生很多难以调试的错误，所以宏是C语言的一把双刃剑。

通常我们在C语言的编程中是不需要经常使用宏的，因为宏有一个缺点： 它只是简单的替换，根本不检查变量和参数类型，所以用得不好会出问题。
不过，很多复杂的库，例如我们在第三部分“用C语言编写游戏”里会介绍的擅长图形界面编程的wxWidgets和Qt，就大量使用了宏。所以对于宏，需要理解。

条件编译

预处理命令除了有以上三个作用以外，还可以实现“条件编译”。听起来有点玄乎，但是只要语文没有还给小学体育老师，那应该不难理解。开个玩笑，我们还是一起来看看如下的例子：

#if 条件1
/* 如果条件1为真，将会被编译的代码 */
#elif 条件2
/* 如果条件2为真，将会被编译的代码 */
#endif

是不是有点类似之前学过的if语句？

可以看到：

关键字#if是一个条件编译块的起始，在后面可以插入一个条件
关键字#elif（else if的缩写）的后面可以插入另一个条件
关键字#endif是一个条件编译块的结束

与if语句不同的是，条件编译没有大括号。

你会发现“条件编译”是相当有用的，它使我们可以按照不同的条件来选择编译哪些代码。

与if语句类似，条件编译块必须有且只能有一个#if，可以没有或有多个#elif，必须有且只能有一个#endif。

如果条件为真，那么后面跟着的代码会被编译，如果条件为假，后面的代码就会在编译时被忽略。

#ifdef和#ifndef

现在我们就来看看之前介绍的“没有数值的#define”的用处。

还记得吗？

#define CONSTANT

我们可以
用#ifdef来表述：“如果此名称已经被定义”
用#ifndef来表述：“如果此名称没有被定义。”

例如我们有如下代码：

#define WINDOWS

#ifdef WINDOWS
/* 当WINDOWS已经被定义的时候要编译的代码 */
#endif

#ifdef LINUX
/* 当LINUX已经被定义的时候要编译的代码 */
#endif

#ifdef MAC
/* 当MAC已经被定义的时候要编译的代码 */
#endif

可以看到，用这样的方法，可以很方便地应对不同平台的编译，使我们的代码实现跨平台。

比如，我要编译针对windows平台的代码，那就在开始处写：

#define WINDOWS

我要编译针对linux的代码，那就改成：

#define LINUX

如果是mac系统，那就改成：

#define MAC

当然了，每次修改代码之后都要重新编译（毕竟没有那么神奇）。

使用#ifndef来避免“重复包含”

#ifndef是非常有用的，经常用于.h头文件中，以避免“重复包含”。

什么是“重复包含”呢？

其实不难理解，设想以下情况：

我有两个头文件，分别命名为 A.h和B.h 。在A.h中我写了

#include "B.h"

而不巧在B.h中我写了

#include "A.h"

要知道，在代码复杂度提高以后，这样的情况不是不可能发生的。很多时候，我们一个文件里要inculde好多个头文件，很容易晕。

这样一来，A.h文件需要B.h来运行，而B.h文件需要A.h来运行。

如果我们稍加思索，就不难想到会发生什么：

电脑读入A.h文件，发现需要包含B.h

电脑在A.h中包含进B.h文件的内容，可是在B.h文件的内容里又发现需要包含A.h

如此循环往复，什么时候是个头啊…

你肯定认为这会永不止息…
事实上，碰到这种情况，预处理器会停止，并且抛出“我受不了这么多包含啦”的错误，你的程序就不能通过编译。

那如何来避免这样的悲剧呢？
下面就是解方。并且从今以后，我强烈建议大家在每一个.h头文件中都这样做！让我任性一回吧...

#ifndef DEF_NAMEOFFILE // 如果此预处理常量还未被定义，即是说这个文件未被包含过
#define DEF_NAMEOFFILE // 定义此预处理常量，以避免重复包含

/* file .h文件的内容 (其他的#include, 函数原型, #define等...) */

#endif

如上所示，在#ifndef和#endif之间我们则放置.h文件的内容（其他的#include, 函数原型, #define等）。

我们来理解一下到底这段代码是怎么起作用的？（我自己第一次碰到这个技术时也有点不太理解）：

假使我们的file.h文件是第一次被包含（被include），预编译器读到开头的那句话：

#ifndef DEF_NAMEOFFILE

意思是《DEF_NAMEOFFILE这个预编译常量还没有被定义》，这个条件是真的。所以预编译器就进入#if语句内部啦（和普通的if语句类似的机制）

接着预编译器就读到第二句命令：

#define DEF_NAMEOFFIL

这句的意思是《定义DEF_NAMEOFFIL这个预处理常量》。所以预编译器乖乖地执行，定义DEF_NAMEOFFIL。

接着它就将file.h头文件的主体内容都包含进调用#include "file.h"或者#include <file.h>的那个文件。

这样的话。下一次这个file.h头文件再在其他文件被包含时，

#ifndef DEF_NAMEOFFILE

这个条件就不为真了，预编译器就不会执行条件编译内部的语句了，自然就不会真的把头文件的主体内容包含了。

这样就能巧妙的避免“重复包含”。

当然，那个预处理常量的名称不一定要和我的一样，也不一定要大写，但是最好大写，习惯用法。
但是每一个头文件的所用常量名称须要不同，否则，只有第一个头文件会被包含。

非常建议大家有空去看一下标准库的头文件，如stdio.h，stdlib.h等。你会发现它们都是以这样的方式写的（开头#ifndef，结尾#endif）。

总结

预处理器是这样一个程序，它在编译之前执行, 它先分析源代码, 然后做出一定修改
预处理命令有好几种。#include命令用于在一个文件中插入另一个文件的内容
#define命令定义一个预处理常量。之后预处理器就会把代码里所有#define定义的常量名称替换成对应的值
宏是一些代码块，定义也要借助#define。宏可以接受参数
我们也可以用预编译器的语言来写一些预编译条件，以实现条件编译。一般我们使用关键字：#if，#elif和#endif等
为了防止一个头文件被多次包含，我们会用条件编译和预处理常量的组合来“保护”它。之后我们写的.h头文件都会采用这种方式，也很建议采用

第二部分第六课预告：

今天的课就到这里，一起加油咯。下一次我们学习： 创建你自己的变量类型