C语言中的预编译详解

目录：

1.预定义符号

2.#define定义常量

3.#define定义宏

4.带有副作用的宏参数

5.宏替换的规则

6.宏函数的对比

7.#和##

8.命名约定

9.#undef

10.命名定义行

11.条件编译

12.头文件的包含

13.其他的预编译指令

1.预定义符号

        C语言设置了一些预定义符号，可以直接使用，预定义符号也是在预处理期间处理的。

        

2.#define定义常量

        基本语法：#define         name(名字)         stuff(内容)

        for example:

        1.#define MAX 1000

        2.#define reg register 

        3.#define forever for(;;);                用更形象的符号来替换实现一种效果(这里实现的是死循环)

        4.#define CASE case;break          在写CASE的时候自动把break写上

        例如：

        

    如果定义的 stuff过长，可以分成几行来写，除了最后一行以外，每行的后面都要加上反斜杠（续航符）。

                        

大家来想一想，define来定义标识符的时候，要不要最后加上；？

比如：

#define        MAX         1000;

#define        MAX         1000

建议不要加上；这样容易导致问题 

例如：

MAX代表的是 1000;，但是max=MAX;相当于max=MAX;;

if不加大括号的时候只能一个语句，多出来的分号导致的空语句，导致编译器报错了。

3.define定义宏

       #define机制包括一个规定，允许把参数替换到文本中，这种实现通常称为宏（macro）或者宏定义（define macro）。

下面是宏定义的申明方式：

         #define  name(parament-list） stuff

其中的parament-list是一个由逗号隔开的符号表，它们可能出现在stuff中。

注意:参数列表的左括号必须与name相连，如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。

举例：

#define SQUARE(x)   x*x

这个宏接受一个参数x，如果上述申明之后，你把SQUARE(5);置于程序中，预处理器就会用下面的这个表达式来替换上面的表达式：5*5

宏定义注意三件事：

1.宏参数不会进行计算，而是直接进行替换。

2.宏的参数中如果有操作符，和宏的内容中的操作符造成宏的运算符优先级问题，可能导致运算顺序不达预期，容易产生问题。

3.宏在书写的时候，给参数都带上括号，不要吝啬括号

4.带有副作用的宏（自增/自减)

当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能出现危险，导致不可预测的结果。副作用就是表达式求值的时候出现永久性的效果。

例如：

        x+1；//不带副作用

        x++;//带有副作用

MAX宏可以证明具有副作用的参数所引起的问题

5.宏替换规则

在程序扩展#define定义符号和宏的时候，需要涉及几个步骤。

1.在调用宏的时候，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，他们首先被替换。

2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。

3.最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处过程。

注意：

1.宏参数和#define定义中是可以出现其他#define定义的符号。但是对于宏，不能出现递归。

2.当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

例如：printf("MAX =%d"，MAX）；

6.宏函数的对比

宏通常被应用于执行简单的运算。

比如在两个数中找出较大的一个的时，携程下面的宏更有优势一些。

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

为什么不用函数来完成这个任务呢?

原因有 二：（优点）

1.用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需的时间更多。使用宏比函数在程序的规模和速度更胜一筹。

2.更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。总之，宏可以适用于整型，长整型，浮点型等可以用于>来比较类型的类型。宏的参数与类型无关 。

和函数相比宏的劣势：

1.每次使用宏的时候，一份宏定义的代码被插入到程序中，除非宏比较短，否则可能大幅度增加程序的长度。

2.宏是没法调试的。

3.宏由于参数与类型无关，也就不够严谨。

4.宏可能带来运算符优先级问题，导致程序容易出现错误。

宏有时候可以做到函数做不到的事情，比如：宏的参数可以出现类型，但是函数做不到。

7.#和##

7.1#运算符

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

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

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

就可以写：

首先补充一个知识点：

printf("Hello"," World!");也是可以打印出Hello World！会把两个字符串粘贴在一起。

实现printf("Hello World!");的效果。

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

PRINTF(a);//当我们把a替换到宏的体内的时候，就出现了#a，而#a就转化为“a”，运行代码时就会出现上面的效果。

7.2##运算符

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

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

这里我们想想，写一个函数求2个数的较大值的时候，不同的数据类型就得写不同的函数，但是这样写的太繁琐了，现在我们这样写代码试试：

相当于输入一个类型生成一个类型有关的函数以及对应的函数名的函数

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

8.命名约定

一般来讲函数和宏的使用语法非常的相似，所以语言本身没办法帮我们区分二者。

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

把宏名一般全部大写

函数名一般不要全部大写

                                                 tip：有例外 offsetof也是宏，不过是全部小写

9.#undef

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

#undef NAME

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

10.命令行定义 

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

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

11.条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们是有条件编译指令。

比如说：调试性的代码删除可惜，保留又碍事，所以我们可以选择性的编译。

常见的条件编译指令：

1.单分支条件编译

2.多分支条件编译

3.判断是否被定义

#if     defined(symbol)

#ifdef symbol

#if     !defined(symbol)

#ifndef symbol

缩写不需要小括号，全写需要小括号

4.嵌套指令

#if defined(A)

        #ifdef A1

                add();

        #endif

        #ifdef  A2

                add2();

        #endif

#elif defined(B)

        #ifdef A3

                add3();

        #endif

#endif

12.头文件的包含

12.1  头文件被包含的方式

12.1.1 本地文件包含

#include “filename"

查找策略：先在源文件所在目录下查找，如果该头文件未被找到，编译器就像查找库函数头文件一样在标准位置查找头文件。

如果找不到就提示编译错误。

Linux环境下标准头文件：

/usr/include

VS环境下标准头文件路径（根据每个版本不同路径也会不同）

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

12.1.2 库函数包含

#include <filename.h>

查找库函数直接去标准路径下去查找，如果找不到就提示编译错误。

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

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

12.2嵌套文件包含

我们已经知道，#include指令，在文件被编译的时候就想它实际出现于#include指令的地方一样。

这种替换方式很简单：预处理器先删除这条指令，并且包含文件的内容替换。

一个头文件被包含10次，那就实际被编译10次，如果重复包含，对编译的压力就比较大。

#include “test.h”

#include “test.h”

#include “test.h”

#include “test.h”

#include “test.h”如果直接这样写，test.c文件将test.h包含5次，那么test.h文件的内容将会被拷贝5份在test.c中，如果test.h文件比较大，这样预处理后代码量会剧增。如果工程比较大，有公共使用的头文件，被大家都能使用，又不做任何处理，那后果将不堪设想。

如何解决头文件被重复引入的问题问题呢？答案：条件编译。/

每一个头文件的开头写：

或者

这两个方法表示头文件只包含一次，这样就可以避免头文件的重复引用。

注：

推荐《高质量C/C++编程指南》中附录的考试试卷（很重要）

笔试题：

1.头文件中的ifndef/define/endif是干什么用的？

2.#include<filename.h>和#include"filename.h"有什么区别？

13.其他预处理指令

1. #eror

2.#pragma

3.line

.........

5.不做太多介绍，大家自己可以去了解下

不过#pragma pack()在结构体中会介绍，主要是为了设置对其数的

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