C语言宏界说利用能力
副标题#e#
写好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 */
#p#副标题#e#
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）属于编译器预处理惩罚的领域，属于编译期观念（而非运行期观念）。下面临常碰着的宏的利用问题做了简朴总结。
宏利用中的常见的基本问题
#标记和##标记的利用
……标记的利用
宏的表明要领
我们能遇到的宏的利用
宏利用中的陷阱
常见的基本性问题：
关于#和##
#p#分页标题#e#
在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
#p#分页标题#e#
由于宏只是简朴的替换，宏的参数假如是复合布局，那么通过替换之后大概由于各个参数之间的操纵符优先级高于单个参数内部各部门之间彼此浸染的操纵符优先级，假如我们不消括号掩护各个宏参数，大概会发生预想不到的景象。好比：
#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）。
