C语言的预处理代码

C语言主要有三种预处理功能：1.文件包含#include 2.宏定义#define 3.条件编译#if  #ifdef等。

预处理是程序在被编译器编译以前，由预处理器预先进行的处理。预处理代码含有“#”作为符号标志，以区分其他源代码。

预处理好处主要是方便提高程序的可读性的维护性，方便开发人员开发代码，还可以提高编译的效率。

预处理的过程主要是指示预处理程序如何修改源代码。在对程序进行通常的编译处理之前，编译程序会自动运行预处理程序，对程序进行编译前的预处理。

比如说当使用#include文件包含时，会在编译之前将include的文件替换到#include的相应位置；当使用#define，会在编译之前将宏替换成实际的参数：当使用条件编译时，会判断是否编译器编译当前的代码段。

1.#include 头文件   

其实就是把 头文件的内容 全部替换到 当前#include处。

关于头文件的好处、来源、用法可以参考http://blog.csdn.net/pashanhuxp/article/details/39927913一文

补充：

①.#include <XXX.h> 和 #include “XXX.h” 的区别：

<XX> 表示在编译器定义的引用目录查找.h头文件；

“XX” 表示先在项目当前目录查找.h头文件，若没有再去编译器指定的目录查找；

所以，若引用自定义的.h头文件，只能用#include “XX”。

②.在Eclipse CDT下，#include "XX.h"  指引用usr/include 目录下的头文件，并不包括子文件夹的头文件，若引用子文件夹下的头文件，需要改为#include “XX/XX.h”

2.#define 宏定义：

宏定义也可以称作“宏替换”，宏会在编译之前被预处理程序替换掉。通常用大写表示

宏定义可以增加程序的可读性和可维护性，比如 #define PI 3.14159

并且宏替换函数，可以提高运行效率，减少函数调用造成的系统开销。比如 #define sum（a，b，c） （a+b+c） 比定义一个求和函数int sum（a,b,c）要节省内存，提高效率。这里需要注意替换的意思，宏是被直接替换的，比如 #define AA a-b      若不加括号，则在使用过程中，会出现cc*AA 变成 cc*a-b 的错误。 

关于空的宏定义的补充：

①空的宏定义修饰函数：#define SUM

代码中有时会出现 #define SUM   并没给宏SUM “赋值” 。这时可以将sum 理解成空的，无意义的。

比如用来修饰函数： SUM int getSum（a，b）  这时可以将SUM的作用理解为对函数作用进行 简单的描述 ，使调用者更明白

②空的宏定义常见于头文件中，防止头文件的内容被重复包含。（平时：最好养成这种写头文件的习惯）

#ifndef _8_4_2_H_
#define _8_4_2_H_

...头文件内容...

#endif /* 8_4_2_H_ */

这时 _8_4_2_H_ 宏就是一个空宏，用于条件编译，有时常见于防止头文件重复包含的用途中。给你举个例子，再顺便分析一下：假设你的工程里面有4个文件，分别是a.cpp,b.h,c.h,d.h。a.cpp的头部是：#include "b.h "#include "c.h "b.h和c.h的头部都是:#include "d.h "而d.h里面有class D的定义。这样一来，编译器编译a.cpp的时候，先根据#include "b.h "去编译b.h这个问题，再根据b.h里面的#include "d.h "，去编译d.h的这个文件，这样就把d.h里面的class D编译了；然后再根据a.cpp的第二句#include "c.h "，去编译c.h，最终还是会找到的d.h里面的class D，但是class D之前已经编译过了，所以就会报重定义错误。

如果在d.h中加上

ifndef  _D_H  

define _D_H    

.......头文件内容......比如定义class D        

endif  

就可以防止这种重定义错误。

③与条件编译结合：

#ifdefine WINDOWS
   ....针对windows的相关处理...
#endif

</pre><pre name="code" class="cpp">#ifdefine LINUX
    ...针对LINUX的相关操作.....
 #endif

则，通过#define WINDOWS 或者 #define LINUX,可以实现多系统下编程。

④#define后只有一个函数，等价空函数：#define FUNCTION(args)  

在头文件中见到过这种情况，FUNCTION(args) 函数在这里define为空，则等价空函数实际不会进行任何处理。

通常，在这个头文件中，还其他已赋值的这个语句 #define FUNCTION(args)  (args*5)

使用举例：

#ifdefine WIN
  #define FUNCTION(args)  (args*5)
#else
  #define  FUNCTION(args)
#endif

如果define了WIN 则FUNCTION(args) 会进行一些具体的操作，否则，FUNTION(args)并不会执行任何处理。

这样定义，方便了调用者，即我在调用的时候，不需要花费代码去判断是不是define了WIN，我都可以在我的代码里直接使用FUNCTION（args）。定义了，则会对参数进行处理，而没有定义的话，不会对参数进行改变。

⑤还有一些编译器预定义宏，格式是“双下划线开头”。主要标识一些编译环境信息。比较少用到。

3.#条件编译

使用条件编译时，会判断是否编译器编译当前的代码段。提高编译效率。

#ifdef 条件
  代码段。。。   
#endif

解释：若宏定义了条件，则执行代码段，否则不执行。

#if 条件
  代码段。。。
#endif

解释：若条件为真，则执行代码段，否则不执行。

使用举例：

#if 0
  A
#endif</span>

实际本代码中A从不执行，这样写是为了方便以后调试更改，若想执行A，则只改为 #if 1即可。

4.#宏和函数的区别（摘自网络）

（1）看一个例子，比较两个数或者表达式大小，首先我们把它写成宏定义：

#define MAX( a, b) ( (a) > (b) (a) : (b) )

其次，把它用函数来实现：

int max( int a, int b)

{  return (a > b a : b)  }

很显然，我们不会选择用函数来完成这个任务，原因有两个：

首先，函数调用会带来额外的开销，它需要开辟一片栈空间，记录返回地址，将形参压栈，从函数返回还要释放堆栈。这种开销不仅会降低代码效率，

而且代码量也会大大增加，而使用宏定义则在代码规模和速度方面都比函数更胜一筹；

其次，函数的参数必须被声明为一种特定的类型，所以它只能在类型合适的表达式上使用，我们如果要比较两个浮点型的大小，就不得不再写一个专门针对浮点型的比较函数。反之，上面的那个宏定义可以用于整形、长整形、单浮点型、双浮点型以及其他任何可以用“>”操作符比较值大小的类型，也就是说，宏是与类型无关的。

（2）和使用函数相比，使用宏的不利之处在于每次使用宏时，一份宏定义代码的拷贝都会插入到程序中。除非宏非常短，否则使用宏会大幅度增加程序的长度。

（3）还有一些任务根本无法用函数实现，但是用宏定义却很好实现。比如参数类型没法作为参数传递给函数，但是可以把参数类型传递给带参的宏。

看下面的例子：

#define MALLOC（n, type） /

（ (type *) malloc（（n）* sizeof（type）））     // “/”为强制换行符，表示下一行其实是在上一行的。

利用这个宏，我们就可以为任何类型分配一段我们指定的空间大小，并返回指向这段空间的指针。我们可以观察一下这个宏确切的工作过程：

int *ptr;

ptr = MALLOC ( 5, int );

将这宏展开以后的结果：

ptr = (int *) malloc ( (5) * sizeof(int) );       // 记住#define其实就是一个“宏替换”

这个例子是宏定义的经典应用之一，完成了函数不能完成的功能，但是宏定义也不能滥用，通常，如果相同的代码需要出现在程序的几个地方，更好的

方法是把它实现为一个函数。