C语言宏定义运用技巧

写好C语言，好看的宏定义很主要，运用宏定义可以防止 出错，提高可移植性，可读性，方便性 等等。下面列举一些成熟软件中常用得宏定义……
　　 1，防止 一个头文件被重复包含
　　 #ifndef COMDEF_H
　　 #define COMDEF_H
　　 //头文件内容
　　 #endif
　　 2，重新定义一些类型，防止 由于各种平台和编译器的不同，而产生的类型字节数差异，方便移植。
　　 typedef unsigned char boolean； /* Boolean value type. */
　　 typedef unsigned long int uint32； /* Unsigned 32 bit value */
　　 typedef unsigned short uint16； /* Unsigned 16 bit value */
　　 typedef unsigned char uint8； /* Unsigned 8 bit value */
　　 typedef signed long int int32； /* Signed 32 bit value */
　　 typedef signed short int16； /* Signed 16 bit value */
　　 typedef signed char int8； /* Signed 8 bit value */
　　 //下面的不建议运用
　　 typedef unsigned char byte； /* Unsigned 8 bit value type. */
　　 typedef unsigned short word； /* Unsinged 16 bit value type. */
　　 typedef unsigned long dword； /* Unsigned 32 bit value type. */
　　 typedef unsigned char uint1； /* Unsigned 8 bit value type. */
　　 typedef unsigned short uint2； /* Unsigned 16 bit value type. */
　　 typedef unsigned long uint4； /* Unsigned 32 bit value type. */
　　 typedef signed char int1； /* Signed 8 bit value type. */
　　 typedef signed short int2； /* Signed 16 bit value type. */       typedef long int int4； /* Signed 32 bit value type. */
　　 typedef signed long sint31； /* Signed 32 bit value */
　　 typedef signed short sint15； /* Signed 16 bit value */
　　 typedef signed char sint7； /* Signed 8 bit value */
　　 3，得到指定地址上的一个字节或字
　　 #define MEM_B（ x ） （ *（ （byte *） （x） ） ）
　　 #define MEM_W（ x ） （ *（ （word *） （x） ） ）
　　 4，求最大值和最小值
　　 #define MAX（ x， y ） （ （（x） > （y）） ？ （x） ： （y） ）
　　 #define MIN（ x， y ） （ （（x） < （y）） ？ （x） ： （y） ）
　　 5，得到一个field在结构体（struct）中的偏移量
　　 #define FPOS（ type， field ）
　　 /*lint -e545 */ （ （dword） &（（ type *） 0）-> field ） /*lint +e545 */
　　 6，得到一个结构体中field所占用的字节数
　　 #define FSIZ（ type， field ） sizeof（ （（type *） 0）->field ）
　　 7，按照LSB格式把两个字节转化为一个Word
　　 #define FLIPW（ ray ） （ （（（word） （ray）[0]） * 256） + （ray）[1] ）
　　 8，按照LSB格式把一个Word转化为两个字节
　　 #define FLOPW（ ray， val ）
　　 （ray）[0] = （（val） / 256）；
　　 （ray）[1] = （（val） & 0xFF）
　　 9，得到一个变量的地址（word宽度）
　　 #define B_PTR（ var ） （ （byte *） （void *） &（var） ）
　　 #define W_PTR（ var ） （ （word *） （void *） &（var） ）
　　 10，得到一个字的高位和低位字节
　　 #define WORD_LO（***） （（byte） （（word）（***） & 255））
　　 #define WORD_HI（***） （（byte） （（word）（***） >> 8））
       11，返回一个比X大的最接近的8的倍数
　　 #define RND8（ x ） （（（（x） + 7） / 8 ） * 8 ）
　　 12，将一个字母转换为大写
　　 #define UPCASE（ c ） （ （（c） >= 'a' && （c） <= 'z'） ？ （（c） - 0x20） ： （c） ）
　　 13，判断字符是不是10进值的数字
　　 #define DECCHK（ c ） （（c） >= '0' && （c） <= '9'）
　　 14，判断字符是不是16进值的数字
　　 #define HEXCHK（ c ） （ （（c） >= '0' && （c） <= '9'）
　　 （（c） >= 'A' && （c） <= 'F'）
　　 （（c） >= 'a' && （c） <= 'f'） ）
　　 15，防止 溢出的一个要领
　　 #define INC_SAT（ val ） （val = （（val）+1 > （val）） ？ （val）+1 ： （val））
　　 16，返回数组元素的个数
　　 #define ARR_SIZE（ a ） （ sizeof（ （a） ） / sizeof（ （a[0]） ） ）
　　 17，返回一个无符号数n尾的值MOD_BY_POWER_OF_TWO（X，n）=X%（2^n）
　　 #define MOD_BY_POWER_OF_TWO（ val， mod_by ）
　　 （ （dword）（val） & （dword）（（mod_by）-1） ）
　　 18，对于IO空间映射在存储空间的结构，输入输出处理
　　 #define inp（port） （*（（volatile byte *） （port）））
　　 #define inpw（port） （*（（volatile word *） （port）））
　　 #define inpdw（port） （*（（volatile dword *）（port）））
　　 #define outp（port， val） （*（（volatile byte *） （port）） = （（byte） （val）））
　　 #define outpw（port， val） （*（（volatile word *） （port）） = （（word） （val）））       #define outpdw（port， val） （*（（volatile dword *） （port）） = （（dword） （val）））
　　 19，运用一些宏跟踪调试
　　 A N S I标准说明了五个预定义的宏名。它们是：
　　 _ L I N E _
　　 _ F I L E _
　　 _ D A T E _
　　 _ T I M E _
　　 _ S T D C _
　　 如果编译不是标准的，则可能仅支持以上宏名中的多个，或根本不支持。记得编译程序
　　 也许还提供其它预定义的宏名。
　　 _ L I N E _及_ F I L E _宏指令在有关# l i n e的部分中已讨论，这里讨论其余的宏名。
　　 _ D AT E _宏指令含有形式为月/日/年的串，表示源文件被翻译到代码时的日期。
　　 源代码翻译到目标代码的时间作为串包含在_ T I M E _中。串形式为时：分：秒。
　　 如果实现是标准的，则宏_ S T D C _含有十进制常量1.如果它含有任何其它数，则实现是非标准的。
　　 可以定义宏，例如：
　　 当定义了_DEBUG，输出数据信息和所在文件所在行
　　 #ifdef _DEBUG
　　 #define DEBUGMSG（msg，date） printf（msg）；printf（“%d%d%d”，date，_LINE_，_FILE_）
　　 #else
　　 #define DEBUGMSG（msg，date）
　　 #endif
　　 20，宏定义防止 运用是不正确
　　 用小括号包含。
　　 例如：#define ADD（a，b） （a+b）
　　 用do{}while（0）语句包含多语句防止 不正确
　　 例如：#difne DO（a，b） a+b；
　　 a++；
　　 运用 时：if（…。）
　　 DO（a，b）； //产生不正确
　　 else
　　 C语言中如何 运用宏
　　 C（和C++）中的宏（Macro）属于编译器预处理的范畴，属于编译期概念（而非运行期概念）。下面对常遇到的宏的运用疑问做了基本总结。
　　 宏运用中的多见的基础疑问
　　 #符号和##符号的运用
　　 ……符号的运用
　　 宏的解释要领
　　 我们能碰到的宏的运用
　　 宏运用中的陷阱
　　 多见的基础性疑问：
　　 关于#和##
　　 在C语言的宏中，#的功能是将其后面的宏参数执行 字符串化操作（Stringfication），基本说就是在对它所引用的宏变量通过替换后在其左右各加上一个双引号。比如下面代码中的宏：
        #define WARN_IF（Exp ）　　　　
　　 do{ if （Exp ）　　　　 fprintf（stderr， "Warning： " #Exp "n"）； }　　　　
　　 while（0）
　　 那么实际运用中会出现下面所示的替换流程：
　　 WARN_IF （divider == 0）；
　　 被替换为
　　 do {
　　 if （divider == 0）
　　 fprintf（stderr， "Warning" "divider == 0" "n"）；
　　 } while（0）；
　　 这样每次divider（除数）为0的时候便会在标准不正确流上输出一个提示信息。
　　 而##被称为连接符（concatenator），用来将两个Token连接为一个Token.留心这里连接的对象是Token就行，而不一定是宏的变量。比如你要做一个菜单项命令名和函数指针组成的结构体的数组，并且希望在函数名和菜单项命令名之间有直观的、名字上的联系。那么下面的代码就非常实用：
　　 struct command
　　 {
　　 char * name；
　　 void （*function） （void）；
　　 }；
　　 #define COMMAND（NAME） { NAME， NAME ## _command }
　　 // 然后你就用一些预先定义好的命令来方便的原始化一个command结构的数组了：
　　 struct command commands[] = {
　　 COMMAND（quit），
　　 COMMAND（help），
　　 ……
　　 } COMMAND宏在这里充当一个代码生成器的作用，这样可以在一定程度上减少代码密度，间接地也可以减少不留心所造成的不正确。我们还可以n个##符号连接 n+1个Token，这个特征也是#符号所不具备的。比如：
　　 #define LINK_MULTIPLE（a，b，c，d） a##_##b##_##c##_##d
　　 typedef struct _record_type LINK_MULTIPLE（name，company，position，salary）；
　　 // 这里这个语句将展开为：
　　 //　　　　 typedef struct _record_type name_company_position_salary；
　　 关于……的运用
　　 ……在C宏中称为Variadic Macro，也就是变参宏。比如：
        #define myprintf（templt，……） fprintf（stderr，templt，__VA_ARGS__）
　　 // 或者
　　 #define myprintf（templt，args……） fprintf（stderr，templt，args）
　　 第一个宏中由于没有对变参起名，我们用默认的宏__VA_ARGS__来替代它。第二个宏中，我们显式地命名变参为args，那么我们在宏定义中就可以用args来代指变参了。同C语言的stdcall一样，变参必须作为参数表的最有一项出现。当上面的宏中我们只能提供第一个参数templt时，C标准要求我们必须写成：myprintf（templt，）；
　　 的形式。这时的替换流程为：
　　 myprintf（"Error！n"，）；
　　 替换为：
　　 fprintf（stderr，"Error！n"，）；
　　 这是一个语法不正确，不能正常编译。这个疑问一般有两个处理要领。首先，GNU CPP提供的处理要领允许上面的宏调用写成：
　　 myprintf（templt）；
　　 而它将会被通过替换变成：
　　 fprintf（stderr，"Error！n"，）；
　　 很明显，这里仍然会产生编译不正确（非本例的某些情况下不会产生编译不正确）。除了这种方式外，c99和GNU CPP都支持下面的宏定义方式：
　　 #define myprintf（templt， ……） fprintf（stderr，templt， ##__VAR_ARGS__）
　　 这时，##这个连接符号充当的作用就是当__VAR_ARGS__为空的时候，消除前面的那个逗号。那么此时的翻译流程如下：
　　 myprintf（templt）；
　　 被转化为：
　　 fprintf（stderr，templt）；
　　 这样如果templt正当，将不会产生编译不正确。
　　 宏是如何 解释的
　　 宏在日常编程中的多见运用
　　 宏运用中的陷阱
　　 这里列出了一些宏运用中容易出错的地点，以及合适的运用方式。
　　 不正确的嵌套－Misnesting
　　 宏的定义不一定要有完整的、配对的括号，但是为了防止出错并且提高可读性，最好防止这样运用。
　　 由操作符优先级引起的疑问－Operator Precedence Problem
　　 由于宏只是基本的替换，宏的参数如果是复合结构，那么通过替换之后可能由于各个参数之间的操作符优先级高于单个参数内部各部分之间相互作用的操作符优先级，如果我们不用括号保卫各个宏参数，可能会产生预想不到的情形。比如：
       #define ceil_div（x， y） （x + y - 1） / y
　　 那么
　　 a = ceil_div（ b & c， sizeof（int） ）；
　　 将被转化为：
　　 a = （ b & c　　　　 + sizeof（int） - 1） / sizeof（int）；
　　 // 由于+/-的优先级高于&的优先级，那么上面式子等同于：
　　 a = （ b & （c + sizeof（int） - 1）） / sizeof（int）；
　　 这显然不是调用者的初衷。为了防止这种情况发生，应当多写多个括号：
　　 define ceil_div（x， y） （（（x） + （y） - 1） / （y））
　　 消除多余的分号－Semicolon Swallowing
　　 通常情况下，为了使函数模样的宏在表面上看起来像一个通常的C语言调用一样，通常情况下我们在宏的后面加上一个分号，比如下面的带参宏：
　　 MY_MACRO（x）；
　　 但是如果是下面的情况：
　　 #define MY_MACRO（x） {
　　 /* line 1 */
　　 /* line 2 */
　　 /* line 3 */ }
　　 //……
　　 if （condition（））
　　 MY_MACRO（a）；
　　 else
　　 {……}
　　 这样会由于多出的那个分号产生编译不正确。为了防止这种情况出现同时保持MY_MACRO（x）；的这种写法，我们须要把宏定义为这种形式：
　　 #define MY_MACRO（x） do {
　　 /* line 1 */
　　 /* line 2 */
　　 /* line 3 */ } while（0）
　　 这样只要保证总是运用分号，就不会有任何疑问。
　　 Duplication of Side Effects
　　 这里的Side Effect是指宏在展开的时候对其参数可能执行 多次Evaluation（也就是取值），但是如果这个宏参数是一个函数，那么就有可能被调用多次从而达到不一致的结果，甚至会发生更严重的不正确。比如：
　　 #define min（X，Y） （（X） > （Y） ？ （Y） ： （X））
　　 //……
　　 c = min（a，foo（b））；
　　 这时foo（）函数就被调用了两次。为了处理这个潜在的疑问，我们应当这样写min（X，Y）这个宏：
       #define min（X，Y） （{
　　 typeof （X） x_ = （X）；
　　 typeof （Y） y_ = （Y）；
　　 （x_ < y_） ？ x_ ： y_； }）
　　 （{……}）的作用是将内部的几条语句中最后一条的值返回，它也允许在内部声明变量（因为它通过大括号组成了一个局部Scope）。