C中的预编译宏定义

C中的预编译宏定义 

在将一个C源程序转换为可执行程序的过程中, 编译预处理是最初的步骤. 这一步骤是由预处理器(preprocessor)来完成的. 在源流程序被编译器处理之前, 预处理器首先对源程序中的"宏(macro)"进行处理.



C初学者可能对预处理器没什么概念, 这是情有可原的: 一般的C编译器都将预处理, 汇编, 编译, 连接过程集成到一起了. 编译预处理往往在后台运行. 在有的C编译器中, 这些过程统统由一个单独的程序来完成, 编译的不同阶段实现这些不同的功能. 可以指定相应的命令选项来执行这些功能. 有的C编译器使用分别的程序来完成这些步骤. 可单独调用这些程序来完成. 在gcc中, 进行编译预处理的程序被称为CPP, 它的可执行文件名为cpp.



编译预处理命令的语法与C语言的语法是完全独立的. 比如: 你可以将一个宏扩展为与C语法格格不入的内容, 但该内容与后面的语句结合在一个若能生成合法的C语句, 也是可以正确编译的.

(一) 预处理命令简介


预处理命令由#(hash字符)开头, 它独占一行, #之前只能是空白符. 以#开头的语句就是预处理命令, 不以#开头的语句为C中的代码行. 常用的预处理命令如下:

#define              定义一个预处理宏

#undef               取消宏的定义

#include            包含文件命令

#include_next   与#include相似, 但它有着特殊的用途

#if                      编译预处理中的条件命令, 相当于C语法中的if语句

#ifdef                判断某个宏是否被定义, 若已定义, 执行随后的语句

#ifndef             与#ifdef相反, 判断某个宏是否未被定义

#elif                  若#if, #ifdef, #ifndef或前面的#elif条件不满足, 则执行#elif之后的语句, 相当于C语法中的else-if

#else                与#if, #ifdef, #ifndef对应, 若这些条件不满足, 则执行#else之后的语句, 相当于C语法中的else

#endif              #if, #ifdef, #ifndef这些条件命令的结束标志.

defined            与#if, #elif配合使用, 判断某个宏是否被定义

#line                标志该语句所在的行号

#                      将宏参数替代为以参数值为内容的字符窜常量

##                   将两个相邻的标记(token)连接为一个单独的标记

#pragma        说明编译器信息

#warning       显示编译警告信息

#error            显示编译错误信息

(二) 预处理的文法


预处理并不分析整个源代码文件, 它只是将源代码分割成一些标记(token), 识别语句中哪些是C语句, 哪些是预处理语句. 预处理器能够识别C标记, 文件名, 空白符, 文件结尾标志.

预处理语句格式:    #command name(...) token(s)

1, command预处理命令的名称, 它之前以#开头, #之后紧随预处理命令, 标准C允许#两边可以有空白符, 但比较老的编译器可能不允许这样. 若某行中只包含#(以及空白符), 那么在标准C中该行被理解为空白. 整个预处理语句之后只能有空白符或者注释, 不能有其它内容.

2, name代表宏名称, 它可带参数. 参数可以是可变参数列表(C99).

3, 语句中可以利用"\"来换行.

e.g.

#  define  ONE 1 /* ONE == 1 */

等价于: #define ONE　１



#define err(flag, msg) if(flag) \

    printf(msg)

等价于: #define err(flag, msg) if(flag) printf(msg)





(三) 预处理命令详述


1, #define

#define 命令定义一个宏:

#define MACRO_NAME(args) tokens(opt)

之后出现的MACRO_NAME将被替代为所定义的标记(tokens). 宏可带参数, 而后面的标记也是可选的.



对象宏

不带参数的宏被称为"对象宏(objectlike macro)"



#define经常用来定义常量, 此时的宏名称一般为大写的字符串. 这样利于修改这些常量.

e.g.

#define MAX 100

int a[MAX];



#ifndef __FILE_H__

#define __FILE_H__

#include "file.h"

#endif

#define __FILE_H__ 中的宏就不带任何参数, 也不扩展为任何标记. 这经常用于包含头文件.



要调用该宏, 只需在代码中指定宏名称, 该宏将被替代为它被定义的内容.



函数宏

带参数的宏也被称为"函数宏". 利用宏可以提高代码的运行效率: 子程序的调用需要压栈出栈, 这一过程如果过于频繁会耗费掉大量的CPU运算资源. 所以一些代码量小但运行频繁的代码如果采用带参数宏来实现会提高代码的运行效率.



函数宏的参数是固定的情况



函数宏的定义采用这样的方式: #define name( args ) tokens

其中的args和tokens都是可选的. 它和对象宏定义上的区别在于宏名称之后不带括号.



注意, name之后的左括号(必须紧跟name, 之间不能有空格, 否则这就定义了一个对象宏, 它将被替换为 以(开始的字符串. 但在调用函数宏时, name与(之间可以有空格.



e.g.

#define mul(x,y) ((x)*(y))



注意, 函数宏之后的参数要用括号括起来, 看看这个例子:

e.g.

#define mul(x,y) x*y

"mul(1, 2+2);" 将被扩展为: 1*2 + 2

同样, 整个标记串也应该用括号引用起来:

e.g.

#define mul(x,y) (x)*(y)

sizeof mul(1,2.0) 将被扩展为 sizeof 1 * 2.0



调用函数宏时候, 传递给它的参数可以是函数的返回值, 也可以是任何有意义的语句:

e.g.

mul (f(a,b), g(c,d));



e.g.

#define insert(stmt) stmt

insert ( a=1; b=2;)  相当于在代码中加入 a=1; b=2 .

insert ( a=1, b=2;)  就有问题了: 预处理器会提示出错: 函数宏的参数个数不匹配. 预处理器把","视为参数间的分隔符. 

insert ((a=1, b=2;)) 可解决上述问题.



在定义和调用函数宏时候, 要注意一些问题:

1, 我们经常用{}来引用函数宏被定义的内容, 这就要注意调用这个函数宏时的";"问题.

example_3.7:

#define swap(x,y) { unsigned long _temp=x; x=y; y=_tmp}

如果这样调用它: "swap(1,2);" 将被扩展为: { unsigned long _temp=1; 1=2; 2=_tmp};

明显后面的;是多余的, 我们应该这样调用: swap(1,2)

虽然这样的调用是正确的, 但它和C语法相悖, 可采用下面的方法来处理被{}括起来的内容:



#define swap(x,y) \

    do { unsigned long _temp=x; x=y; y=_tmp} while (0)

swap(1,2); 将被替换为:

do { unsigned long _temp=1; 1=2; 2=_tmp} while (0);

在Linux 内核源代码中对这种do-while(0)语句有这广泛的应用.



2, 有的函数宏是无法用do-while(0)来实现的, 所以在调用时不能带上";", 最好在调用后添加注释说明.

eg_3.8:

#define incr(v, low, high) \

    for ((v) = (low),; (v) <= (high); (v)++)

只能以这样的形式被调用: incr(a, 1, 10)  /* increase a form 1 to 10 */



函数宏中的参数包括可变参数列表的情况

C99标准中新增了可变参数列表的内容. 不光是函数, 函数宏中也可以使用可变参数列表.



#define name(args, ...) tokens

#define name(...) tokens

"..."代表可变参数列表, 如果它不是仅有的参数, 那么它只能出现在参数列表的最后. 调用这样的函数宏时, 传递给它的参数个数要不少于参数列表中参数的个数(多余的参数被丢弃).

通过__VA_ARGS__来替换函数宏中的可变参数列表. 注意__VA_ARGS__只能用于函数宏中参数中包含有"..."的情况.



e.g.

#ifdef DEBUG

#define my_printf(...) fprintf(stderr, __VA_ARGS__)

#else

#define my_printf(...) printf(__VA_ARGS__)

#endif



tokens中的__VA_ARGS__被替换为函数宏定义中的"..."可变参数列表.



注意在使用#define时候的一些常见错误:

#define MAX = 100

#define MAX 100;

=, ; 的使用要值得注意. 再就是调用函数宏是要注意, 不要多给出";".





注意: 函数宏对参数类型是不敏感的, 你不必考虑将何种数据类型传递给宏. 那么, 如何构建对参数类型敏感的宏呢? 参考本章的第九部分, 关于"##"的介绍.



关于定义宏的另外一些问题

(1) 宏可以被多次定义, 前提是这些定义必须是相同的. 这里的"相同"要求先后定义中空白符出现的位置相同, 但具体的空白符类型或数量可不同, 比如原先的空格可替换为多个其他类型的空白符: 可为tab, 注释...

e.g.

#define NULL 0

#define NULL　/* null pointer */     0

上面的重定义是相同的, 但下面的重定义不同:

#define fun(x) x+1

#define fun(x) x + 1 或: #define fun(y) y+1

如果多次定义时, 再次定义的宏内容是不同的, gcc会给出"NAME redefined"警告信息.



应该避免重新定义函数宏, 不管是在预处理命令中还是C语句中, 最好对某个对象只有单一的定义. 在gcc中, 若宏出现了重定义, gcc会给出警告.



(2) 在gcc中, 可在命令行中指定对象宏的定义:

e.g.

$ gcc -Wall -DMAX=100 -o tmp tmp.c

相当于在tmp.c中添加" #define MAX 100".



那么, 如果原先tmp.c中含有MAX宏的定义, 那么再在gcc调用命令中使用-DMAX, 会出现什么情况呢?

---若-DMAX=1, 则正确编译.

---若-DMAX的值被指定为不为1的值, 那么gcc会给出MAX宏被重定义的警告, MAX的值仍为1.



注意: 若在调用gcc的命令行中不显示地给出对象宏的值, 那么gcc赋予该宏默认值(1), 如: -DVAL == -DVAL=1



(3) #define所定义的宏的作用域

宏在定义之后才生效, 若宏定义被#undef取消, 则#undef之后该宏无效. 并且字符串中的宏不会被识别

e.g.

#define ONE 1

sum = ONE + TWO    /* sum = 1 + TWO  */

#define TWO 2

sum = ONE + TWO    /* sum = 1 + 2    */ 

#undef ONE

sum = ONE + TWO    /* sum = ONE + 2  */



char c[] = "TWO"   /* c[] = "TWO", NOT "2"! */



(4) 宏的替换可以是递归的, 所以可以嵌套定义宏.

e.g.

# define ONE NUMBER_1

# define NUMBER_1 1

int a = ONE  /* a = 1 */



2, #undef

#undef用来取消宏定义, 它与#define对立:

#undef name

如够被取消的宏实际上没有被#define所定义, 针对它的#undef并不会产生错误.

当一个宏定义被取消后, 可以再度定义它.



3, #if, #elif, #else, #endif

#if, #elif, #else, #endif用于条件编译:



#if 常量表达式1

    语句...

#elif 常量表达式2

    语句...

#elif 常量表达式3

    语句...

...

#else

    语句...

#endif



#if和#else分别相当于C语句中的if, else. 它们根据常量表达式的值来判别是否执行后面的语句. #elif相当于C中的else-if. 使用这些条件编译命令可以方便地实现对源代码内容的控制.

else之后不带常量表达式, 但若包含了常量表达式, gcc只是给出警告信息.



使用它们可以提升代码的可移植性---针对不同的平台使用执行不同的语句. 也经常用于大段代码注释.

e.g.

#if 0

{

    一大段代码;

}

#endif



常量表达式可以是包含宏, 算术运算, 逻辑运算等等的合法C常量表达式, 如果常量表达式为一个未定义的宏, 那么它的值被视为0.

#if MACRO_NON_DEFINED  == #if 0

在判断某个宏是否被定义时, 应当避免使用#if, 因为该宏的值可能就是被定义为0. 而应当使用下面介绍的#ifdef或#ifndef.



注意: #if, #elif, #else之后的宏只能是对象宏. 如果name为名的宏未定义, 或者该宏是函数宏. 那么在gcc中使用"-Wundef"选项会显示宏未定义的警告信息.



4, #ifdef, #ifndef, defined.

#ifdef, #ifndef, defined用来测试某个宏是否被定义

#ifdef name  或 #ifndef name



它们经常用于避免头文件的重复引用:

#ifndef __FILE_H__

#define __FILE_H__

#include "file.h"

#endif



defined(name): 若宏被定义,则返回1, 否则返回0.

它与#if, #elif, #else结合使用来判断宏是否被定义, 乍一看好像它显得多余, 因为已经有了#ifdef和#ifndef. defined用于在一条判断语句中声明多个判别条件:



#if defined(VAX) && defined(UNIX) && !defined(DEBUG)



和#if, #elif, #else不同, #indef, #ifndef, defined测试的宏可以是对象宏, 也可以是函数宏. 在gcc中使用"-Wundef"选项不会显示宏未定义的警告信息.



5, #include , #include_next

#include用于文件包含. 在#include 命令所在的行不能含有除注释和空白符之外的其他任何内容.

#include "headfile"

#include <headfile>

#include 预处理标记

前面两种形式大家都很熟悉, "#include 预处理标记"中, 预处理标记会被预处理器进行替换, 替换的结果必须符合前两种形式中的某一种.



实际上, 真正被添加的头文件并不一定就是#include中所指定的文件. #include"headfile"包含的头文件当然是同一个文件, 但#include <headfile>包包含的"系统头文件"可能是另外的文件. 但这不值得被注意. 感兴趣的话可以查看宏扩展后到底引入了哪些系统头文件.



关于#include "headfile"和#include <headfile>的区别以及如何在gcc中包含头文件的详细信息, 参考本blog的GCC笔记.



相对于#include, 我们对#include_next不太熟悉. #include_next仅用于特殊的场合. 它被用于头文件中(#include既可用于头文件中, 又可用于.c文件中)来包含其他的头文件. 而且包含头文件的路径比较特殊: 从当前头文件所在目录之后的目录来搜索头文件.

比如: 头文件的搜索路径一次为A,B,C,D,E. #include_next所在的当前头文件位于B目录, 那么#include_next使得预处理器从C,D,E目录来搜索#include_next所指定的头文件.



可参考cpp 手册进一步了解#include_next



6, 预定义宏

标准C中定义了一些对象宏, 这些宏的名称以"__"开头和结尾, 并且都是大写字符. 这些预定义宏可以被#undef, 也可以被重定义.



下面列出一些标准C中常见的预定义对象宏(其中也包含gcc自己定义的一些预定义宏:

__LINE__             当前语句所在的行号, 以10进制整数标注.

__FILE__             当前源文件的文件名, 以字符串常量标注.

__DATE__            程序被编译的日期, 以"Mmm dd yyyy"格式的字符串标注.

__TIME__            程序被编译的时间, 以"hh:mm:ss"格式的字符串标注, 该时间由asctime返回.



__STDC__            如果当前编译器符合ISO标准, 那么该宏的值为1

__STDC_VERSION__    如果当前编译器符合C89, 那么它被定义为199409L, 如果符合C99, 那么被定义为199901L.

                    我用gcc, 如果不指定-std=c99, 其他情况都给出__STDC_VERSION__未定义的错误信息, 咋回事呢?

__STDC_HOSTED__        如果当前系统是"本地系统(hosted)", 那么它被定义为1. 本地系统表示当前系统拥有完整的标准C库.





gcc定义的预定义宏:

__OPTMIZE__            如果编译过程中使用了优化, 那么该宏被定义为1.

__OPTMIZE_SIZE__    同上, 但仅在优化是针对代码大小而非速度时才被定义为1.

__VERSION__            显示所用gcc的版本号.

可参考"GCC the complete reference".

要想看到gcc所定义的所有预定义宏, 可以运行: $ cpp -dM /dev/null



7, #line

#line用来修改__LINE__和 __FILE__.

e.g.

  printf("line: %d, file: %s\n", __LINE__, __FILE__);

#line 100 "haha"

  printf("line: %d, file: %s\n", __LINE__, __FILE__);

  printf("line: %d, file: %s\n", __LINE__, __FILE__);



显示:

line: 34, file: 1.c

line: 100, file: haha

line: 101, file: haha



8, #pragma, _Pragma

#pragma 用编译器用来添加新的预处理功能或者显示一些编译信息. #pragma的格式是各编译器特定的, gcc的如下:

#pragma GCC name token(s)



#pragma 之后有两个部分: GCC和特定的pragma name. 下面分别介绍gcc中常用的.



(1) #pragma GCC dependency

dependency测试当前文件(既该语句所在的程序代码)与指定文件(既#pragma语句最后列出的文件)的时间戳. 如果指定文件比当前文件新, 则给出警告信息.

e.g.

在 demo.c中给出这样一句:

#pragma GCC dependency "temp-file"

然后在demo.c所在的目录新建一个更新的文件: $ touch temp-file, 编译: $ gcc demo.c 会给出这样的警告信息:  warning: current file is older than temp-file

如果当前文件比指定的文件新, 则不给出任何警告信息.



还可以在在#pragma中给添加自定义的警告信息.

e.g.

#pragma GCC dependency "temp-file" "demo.c needs to be updated!"

1.c:27:38: warning: extra tokens at end of #pragma directive

1.c:27:38: warning: current file is older than temp-file

注意: 后面新增的警告信息要用""引用起来, 否则gcc将给出警告信息.



(2) #pragma GCC poison token(s)

若源代码中出现了#pragma中给出的 token(s), 则编译时显示警告信息. 它一般用于在调用你不想使用的函数时候给出出错信息.

e.g.

#pragma GCC poison scanf

scanf("%d", &a);

warning: extra tokens at end of #pragma directive

error: attempt to use poisoned "scanf"

注意, 如果调用了poison中给出的标记, 那么编译器会给出的是出错信息. 关于第一条警告, 我还不知道怎么避免, 用""将token(s)引用起来也不行.



(3) #pragma GCC system_header

从#pragma GCC system_header直到文件结束之间的代码会被编译器视为系统头文件之中的代码. 系统头文件中的代码往往不能完全遵循C标准, 所以头文件之中的警告信息往往不显示. (除非用 #warning显式指明).

(这条#pragma语句还没发现用什么大的用处



)



由于#pragma不能用于宏扩展, 所以gcc还提供了_Pragma:

e.g.

#define PRAGMA_DEP #pragma GCC dependency "temp-file"

由于预处理之进行一次宏扩展, 采用上面的方法会在编译时引发错误, 要将#pragma语句定义成一个宏扩展, 应该使用下面的_Pragma语句:

#define PRAGMA_DEP _Pragma("GCC dependency \"temp-file\"")

注意, ()中包含的""引用之前引该加上\转义字符.



9, #, ##

#和##用于对字符串的预处理操作, 所以他们也经常用于printf, puts之类的字符串显示函数中.

#用于在宏扩展之后将 tokens转换为以tokens为内容的字符串常量.

e.g.

#define TEST(a,b) printf( #a "<" #b "=%d\n", (a)<(b));

注意: #只针对紧随其后的token有效!

##用于将它前后的两个 token组合在一起转换成以这两个token为内容的字符串常量. 注意##前后必须要有token.

e.g.

#define TYPE(type, n) type n



之后调用:

TYPE(int, a) = 1;

TYPE(long, b) = 1999;

将被替换为:

int a = 1;

long b = 1999;



(10) #warning, #error

#warning, #error分别用于在编译时显示警告和错误信息, 格式如下:

#warning tokens

#error tokens

e.g.

#warning "some warning"

注意, #error和#warning后的token要用""引用起来!

(在gcc中, 如果给出了warning, 编译继续进行, 但若给出了error, 则编译停止. 若在命令行中指定了 -Werror, 即使只有警告信息, 也不编译.





本文内容收集自网络，仅供自己学习和大家交流之用，如果侵犯了您的权益，请及时通知，会及时撤下！

预处理过程扫描源代码，对其进行初步的转换，产生新的源代码提供给编译器。可见预处理过程先于编译器对源代码进行处理。

在C语言中，并没有任何内在的机制来完成如下一些功能：在编译时包含其他源文件、定义宏、根据条件决定编译时是否包含某些代码。要完成这些工作，就需要使用预处理程序。尽管在目前绝大多数编译器都包含了预处理程序，但通常认为它们是独立于编译器的。预处理过程读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行响应的转换。预处理过程还会删除程序中的注释和多余的空白字符。

预处理指令是以#号开头的代码行。#号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。下面是部分预处理指令：



        指令             用途

         #           空指令，无任何效果

         #include    包含一个源代码文件

         #define     定义宏

         #undef      取消已定义的宏

         #if         如果给定条件为真，则编译下面代码

         #ifdef      如果宏已经定义，则编译下面代码

         #ifndef     如果宏没有定义，则编译下面代码

         #elif       如果前面的#if给定条件不为真，当前条件为真，则编译下面代码

         #endif      结束一个#if……#else条件编译块

         #error      停止编译并显示错误信息



一、文件包含

    #include预处理指令的作用是在指令处展开被包含的文件。包含可以是多重的，也就是说一个被包含的文件中还可以包含其他文件。标准C编译器至少支持八重嵌套包含。

    预处理过程不检查在转换单元中是否已经包含了某个文件并阻止对它的多次包含。这样就可以在多次包含同一个头文件时，通过给定编译时的条件来达到不同的效果。例如：



        #define AAA

        #include &quot;t.c&quot;

        #undef AAA

        #include &quot;t.c&quot;



    为了避免那些只能包含一次的头文件被多次包含，可以在头文件中用编译时条件来进行控制。例如：

        /*my.h*/

        #ifndef MY_H

        #define MY_H

          ……

        #endif



    在程序中包含头文件有两种格式：

        #include &lt;my.h&gt;

        #include &quot;my.h&quot;

   第一种方法是用尖括号把头文件括起来。这种格式告诉预处理程序在编译器自带的或外部库的头文件中搜索被包含的头文件。第二种方法是用双引号把头文件括起来。这种格式告诉预处理程序在当前被编译的应用程序的源代码文件中搜索被包含的头文件，如果找不到，再搜索编译器自带的头文件。

   采用两种不同包含格式的理由在于，编译器是安装在公共子目录下的，而被编译的应用程序是在它们自己的私有子目录下的。一个应用程序既包含编译器提供的公共头文件，也包含自定义的私有头文件。采用两种不同的包含格式使得编译器能够在很多头文件中区别出一组公共的头文件。



二、宏

   宏定义了一个代表特定内容的标识符。预处理过程会把源代码中出现的宏标识符替换成宏定义时的值。宏最常见的用法是定义代表某个值的全局符号。宏的第二种用法是定义带参数的宏，这样的宏可以象函数一样被调用，但它是在调用语句处展开宏，并用调用时的实际参数来代替定义中的形式参数。

    1.#define指令

        #define预处理指令是用来定义宏的。该指令最简单的格式是：首先神明一个标识符，然后给出这个标识符代表的代码。在后面的源代码中，就用这些代码来替代该标识符。这种宏把程序中要用到的一些全局值提取出来，赋给一些记忆标识符。

            #define MAX_NUM 10

            int array[MAX_NUM];

            for(i=0;i&lt;MAX_NUM;i++)  /*……*/

       

       在这个例子中，对于阅读该程序的人来说，符号MAX_NUM就有特定的含义，它代表的值给出了数组所能容纳的最大元素数目。程序中可以多次使用这个值。作为一种约定，习惯上总是全部用大写字母来定义宏，这样易于把程序红的宏标识符和一般变量标识符区别开来。如果想要改变数组的大小，只需要更改宏定义并重新编译程序即可。

        宏表示的值可以是一个常量表达式，其中允许包括前面已经定义的宏标识符。例如：

            #define ONE 1

            #define TWO 2

            #define THREE (ONE+TWO)

        注意上面的宏定义使用了括号。尽管它们并不是必须的。但出于谨慎考虑，还是应该加上括号的。例如：

            six=THREE*TWO;

        预处理过程把上面的一行代码转换成：

            six=(ONE+TWO)*TWO;

        如果没有那个括号，就转换成six=ONE+TWO*TWO;了。

        宏还可以代表一个字符串常量，例如：

            #define VERSION &quot;Version 1.0 Copyright(c) 2003&quot;

    2.带参数的#define指令

        带参数的宏和函数调用看起来有些相似。看一个例子：

            #define Cube(x) (x)*(x)*(x)

        可以时任何数字表达式甚至函数调用来代替参数x。这里再次提醒大家注意括号的使用。宏展开后完全包含在一对括号中，而且参数也包含在括号中，这样就保证了宏和参数的完整性。看一个用法：

            int num=8+2;

            volume=Cube(num);

        展开后为(8+2)*(8+2)*(8+2);

        如果没有那些括号就变为8+2*8+2*8+2了。

        下面的用法是不安全的：

            volume=Cube(num++);

        如果Cube是一个函数，上面的写法是可以理解的。但是，因为Cube是一个宏，所以会产生副作用。这里的擦书不是简单的表达式，它们将产生意想不到的结果。它们展开后是这样的：

            volume=(num++)*(num++)*(num++);

        很显然，结果是10*11*12,而不是10*10*10;

        那么怎样安全的使用Cube宏呢？必须把可能产生副作用的操作移到宏调用的外面进行：

            int num=8+2;

            volume=Cube(num);

            num++;

    3.#运算符

        出现在宏定义中的#运算符把跟在其后的参数转换成一个字符串。有时把这种用法的#称为字符串化运算符。例如：



            #define PASTE(n) &quot;adhfkj&quot;#n



            main()

            {

               printf(&quot;%s\n&quot;,PASTE(15));

            }

        宏定义中的#运算符告诉预处理程序，把源代码中任何传递给该宏的参数转换成一个字符串。所以输出应该是adhfkj15。

    4.##运算符

        ##运算符用于把参数连接到一起。预处理程序把出现在##两侧的参数合并成一个符号。看下面的例子：



            #define NUM(a,b,c) a##b##c

            #define STR(a,b,c) a##b##c



            main()

            {

                printf(&quot;%d\n&quot;,NUM(1,2,3));

                printf(&quot;%s\n&quot;,STR(&quot;aa&quot;,&quot;bb&quot;,&quot;cc&quot;));

            }



        最后程序的输出为:

                 123

                 aabbcc

        千万别担心，除非需要或者宏的用法恰好和手头的工作相关，否则很少有程序员会知道##运算符。绝大多数程序员从来没用过它。



三、条件编译指令

    条件编译指令将决定那些代码被编译，而哪些是不被编译的。可以根据表达式的值或者某个特定的宏是否被定义来确定编译条件。

    1.#if指令

        #if指令检测跟在制造另关键字后的常量表达式。如果表达式为真，则编译后面的代码，知道出现#else、#elif或#endif为止；否则就不编译。

    2.#endif指令

        #endif用于终止#if预处理指令。



            #define DEBUG 0

            main()

            {

                #if DEBUG

                    printf(&quot;Debugging\n&quot;);

                #endif

                    printf(&quot;Running\n&quot;);

            }



        由于程序定义DEBUG宏代表0，所以#if条件为假，不编译后面的代码直到#endif，所以程序直接输出Running。

        如果去掉#define语句，效果是一样的。

    3.#ifdef和#ifndef

        #define DEBUG



        main()

        {

            #ifdef DEBUG

                printf(&quot;yes\n&quot;);

            #endif

            #ifndef DEBUG

                printf(&quot;no\n&quot;);

            #endif

        }

        #if defined等价于#ifdef; #if !defined等价于#ifndef

    4.#else指令

        #else指令用于某个#if指令之后，当前面的#if指令的条件不为真时，就编译#else后面的代码。#endif指令将中指上面的条件块。



        #define DEBUG



        main()

        {

            #ifdef DEBUG

                printf(&quot;Debugging\n&quot;);

            #else

                printf(&quot;Not debugging\n&quot;);

            #endif

                printf(&quot;Running\n&quot;);

       }



    5.#elif指令

        #elif预处理指令综合了#else和#if指令的作用。



        #define TWO



        main()

        {

            #ifdef ONE

                printf(&quot;1\n&quot;);

            #elif defined TWO

                printf(&quot;2\n&quot;);

            #else

                printf(&quot;3\n&quot;);

            #endif

        }

        程序很好理解，最后输出结果是2。



    6.其他一些标准指令

        #error指令将使编译器显示一条错误信息，然后停止编译。

        #line指令可以改变编译器用来指出警告和错误信息的文件号和行号。

        #pragma指令没有正式的定义。编译器可以自定义其用途。典型的用法是禁止或允许某些烦人的警告信息。







一：#pragma warning指令



该指令允许有选择性的修改编译器的警告消息的行为

指令格式如下:

#pragma warning( warning-specifier : warning-number-list [; warning-specifier : warning-number-list...]

#pragma warning( push[ ,n ] )

#pragma warning( pop )



主要用到的警告表示有如下几个:



once:只显示一次(警告/错误等)消息

default:重置编译器的警告行为到默认状态

1,2,3,4:四个警告级别

disable:禁止指定的警告信息

error:将指定的警告信息作为错误报告



如果大家对上面的解释不是很理解,可以参考一下下面的例子及说明



#pragma warning( disable : 4507 34; once : 4385; error : 164 )

等价于：

#pragma warning(disable:4507 34) // 不显示4507和34号警告信息

#pragma warning(once:4385)        // 4385号警告信息仅报告一次

#pragma warning(error:164)        // 把164号警告信息作为一个错误。

同时这个pragma warning 也支持如下格式：

#pragma warning( push [ ,n ] )

#pragma warning( pop )

这里n代表一个警告等级(1---4)。

#pragma warning( push )保存所有警告信息的现有的警告状态。

#pragma warning( push, n)保存所有警告信息的现有的警告状态，并且把全局警告

等级设定为n。 

#pragma warning( pop )向栈中弹出最后一个警告信息，在入栈和出栈之间所作的

一切改动取消。例如：

#pragma warning( push )

#pragma warning( disable : 4705 )

#pragma warning( disable : 4706 )

#pragma warning( disable : 4707 )

#pragma warning( pop )



在这段代码的最后，重新保存所有的警告信息(包括4705，4706和4707)



在使用标准C++进行编程的时候经常会得到很多的警告信息,而这些警告信息都是不必要的提示,

所以我们可以使用#pragma warning(disable:4786)来禁止该类型的警告



在vc中使用ADO的时候也会得到不必要的警告信息,这个时候我们可以通过

#pragma warning(disable:4146)来消除该类型的警告信息



二：#pragma pack()

注：如果设置的值比结构体中字节最长的类型还要大，则这个变量(注意仅针对这一个变量)只按照它的字节长度对齐，即不会出现内存浪费的情况。请参见 (4)。

(1)

#pragma pack(1)        //每个变量按照1字节对齐

struct A

{

char x;    //aligned on byte boundary 0

int y;     //aligned on byte boundary 1

}a;

sizeof(a)==5

(2)

#pragma pack(2)        //每个变量按照2字节对齐

struct A

{

char x;    //aligned on byte boundary 0

int y;     //aligned on byte boundary 2

}a;

sizeof(a)==6

(3)

#pragma pack(4)        //每个变量按照4字节对齐

struct A

{

char x;    //aligned on byte boundary 0

int y;     //aligned on byte boundary 4

}a;

sizeof(a)==8

(4)

#pragma pack()        //默认，相当于#pragma pack(8) 每个变量按照8字节对齐

struct A

{

char x;    //aligned on byte boundary 0

int y;     //aligned on byte boundary 4

}a;

sizeof(a)==8

但是这里y的大小是4字节，所以不会按照8字节对齐，否则将造成1个int空间的浪费



三.#pragma comment

The following pragma causes the linker to search for the EMAPI.LIBlibrary while linking. The linker searches first in the current workingdirectory and then in the path specified in the LIB environmentvariable:

#pragma comment( lib, &quot;emapi&quot; )





四.#pragma deprecated

When the compiler encounters a deprecated symbol, it issues C4995:

void func1(void) {}

void func2(void) {}

int main() {

   func1();

   func2();

   #pragma deprecated(func1, func2)

   func1();   // C4995

   func2();   // C4995

}

五.#pragma message

The following code fragment uses the message pragma to display a message during compilation:

#if _M_IX86 == 500

#pragma message( &quot;Pentium processor build&quot; )

#endif