关于宏，预定义资料的收集（—）

以下资料自己学习收集。

 

宏定义的一些使用技巧总结大全（二）
3. "#"和"##"的一些应用特例
(1)合并匿名变量名
   #define  ___ANONYMOUS1(type, var, line)  type  var##line
    #define  __ANONYMOUS0(type, line)  ___ANONYMOUS1(type, _anonymous, line)
   #define  ANONYMOUS(type)  __ANONYMOUS0(type, __LINE__)
   例：ANONYMOUS(static int);  即: static int _anonymous70;  70表示该行行号;
   第一层：ANONYMOUS(static int);  -->  __ANONYMOUS0(static int, __LINE__);
   第二层：                        -->  ___ANONYMOUS1(static int, _anonymous, 70);
   第三层：                        -->  static int  _anonymous70;
   即每次只能解开当前层的宏,所以__LINE__在第二层才能被解开;

(2)填充结构
   #define  FILL(a)   {a, #a}

   enum IDD{OPEN, CLOSE};
   typedef struct MSG{
     IDD id;
     const char * msg;
   }MSG;

   MSG _msg[] = {FILL(OPEN), FILL(CLOSE)};
   相当于：
   MSG _msg[] = {{OPEN,  "OPEN"},
                 {CLOSE, "CLOSE"}};

(3)记录文件名
   #define  _GET_FILE_NAME(f)   #f
   #define  GET_FILE_NAME(f)    _GET_FILE_NAME(f)
   static char  FILE_NAME[] = GET_FILE_NAME(__FILE__);

(4)得到一个数值类型所对应的字符串缓冲大小
   #define  _TYPE_BUF_SIZE(type)  sizeof #type
   #define  TYPE_BUF_SIZE(type)   _TYPE_BUF_SIZE(type)
   char  buf[TYPE_BUF_SIZE(INT_MAX)];
     -->  char  buf[_TYPE_BUF_SIZE(0x7fffffff)];
     -->  char  buf[sizeof "0x7fffffff"];
   这里相当于：
   char  buf[11];

......符号的使用
   ......在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合法，将不会产生编译错误。

   另外，在vxworks中，还可以允许下面的宏定义:

   #define myprintf(arg...)        printf(arg)

   宏的第一个参数就设置为变参，因此下面的几种使用方式都是正确的:

   myprintf("number");
   myprintf("number %d",2);
   myprintf("number %d %d",2,3);

宏使用中的陷阱
   这里列出了一些宏使用中容易出错的地方，以及合适的使用方式。

   错误的嵌套－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)。
写好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)))

http://www.mobpub.net/redirect.php?tid=4196&goto=lastpost