浅谈宏定义使用技巧

  1、宏定义介绍   

      宏定义又称为宏替换，简称宏。它是在预处理阶段用预先定义的字符串替代标识符的过程。其定义的一般形式为：
 #define    标识符    字符串 
      宏定义中的标识符都采用大写，这是编程中一种约定俗成的习惯。在了解如何使用宏定义之前，我们先来了解使用宏的过程中需要注意的几个要点。
      1）宏替换不做语法检查，所以在使用的时候要格外小心。   
      2）宏替换通常在文件开头部分，写在函数的花括号外边，作用域为其后的程序，直到用   ❑
      3）# u n d e f 命令终止宏定义的作用域。
      4）不要在字符串中使用宏，如果宏名出现在字符串中，那么将按字符串进行处理

2、宏定义会用的意义

     1 ）减少不必要的修改，提升程序的可预读性

     2 ）提升代码的可移植性 

3、 如何使用宏定义实现变参     

#define    print(...)   printf(__VA_ARGS__) 

     在这个宏中，“. . . ”指可变参数。可变参数的实现方式就是使用“. . . ”所代表的内容替代
_ _ VA _ A R G S _ _ ，看看下面的代码。

  

#include <stdio.h>

#ifdef TEMP
#define print(...) printf(__VA_ARGS__)
#else
#define print(temp, ...) fprintf(stdout, temp, ##__VA_ARGS__)
#endif
int main()
{
    
    print("hello world-------%d\n",1111);
    return 0;
}

编译时带 -DTEMP或不带的情况都能正确打印出要打印的内容。但是在第二个宏定义时加##是什么意思？

# ”的作用就是对其后面的宏参数进行字符串化操作；##作用是粘合，将前后两个部分粘合成一个整体。

***************************************************************************************************************************************************

下面在其他博客中中找到的相关说明，来看下：

#define A          (2) 
#define STR(s)     #s 
#define CONS(a,b)  int(a##e##b) 

printf("int max: %s\n",  STR(INT_MAX));    // INT_MAX #i nclude 
这行会被展开为: 
printf("int max: %s\n", "INT_MAX"); 

printf("%s\n", CONS(A, A));               // compile error   
这一行则是: 
printf("%s\n", int(AeA)); 

INT_MAX和A都不会再被展开, 然而解决这个问题的方法很简单. 加多一层中间转换宏. 
加这层宏的用意是把所有宏的参数在这层里全部展开, 那么在转换宏里的那一个宏(_STR)就能得到正确的宏参数. 

#define A           (2) 
#define _STR(s)     #s 
#define STR(s)      _STR(s)          // 转换宏 
#define _CONS(a,b)  int(a##e##b) 
#define CONS(a,b)   _CONS(a,b)       // 转换宏 

printf("int max: %s\n", STR(INT_MAX));          // INT_MAX,int型的最大值,为一个变量 #i nclude 
输出为: int max: 0x7fffffff 
STR(INT_MAX) -->  _STR(0x7fffffff) 然后再转换成字符串; 

printf("%d\n", CONS(A, A)); 
输出为:200 
CONS(A, A)  -->  _CONS((2), (2))  --> int((2)e(2)) 

三、'#'和'##'的一些应用特例 
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];

使用一些宏跟踪调试 

A N S I标准说明了五个预定义的宏名。它们是： 

_ L I N E _ (两个下划线)，对应%d

_ F I L E _    对应%s

_ D A T E _   对应%s

_ T I M E _   对应%s

_ 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。如果它含有任何其它数,则实现是 

非标准的。 

******************************************************************************************************************
下面是个例子，介绍上述宏定义在代码调试中的例子

#define return_exam(p) if(!(p)) \ 
{printf("error: "#p" file_name:%s\tfunction_name:%s\tline:%d .\n",\  
            __FILE__, __func__, __LINE__); return 0;}

int print()
{
    return_exam(0);
}
int main ()
{
    print();
    printf("hello world!!! %s(),%s,%d\n",__FILE__,__func__,__LINE__);
    return 0;
}

james@jsh:~/C_stuty/study$ ./a.out 
error: 0 file_name:define.c	function_name:print	line:25 .
hello world!!! define.c(),main,30

四 、# p r a g m a 指令的使用  

       预处理中的# p r a g m a   指令，其作用是设置编译器的状态或指示编译器完成一些特定的动作。使用# p r a g m a 指令的一般形式为：

       #pragma  para 

     其中，p a r a 为参数。下面对一些常见的参数进行讲解。

     1） # p r a g m a     m e s s a g e ( " 消息" )

      至于“# p r a g m a   m e s s a g e ( " 消息" ) ”究竟有什么作用，可以通过下面的一段代码来了解其
具体的使用方式。

 

#include<stdio.h>      

#define STR   

void main(int argc,char*argv)    
{    
    printf(" 学习#pragma命令中message参数的使用!\n");
#ifdef STR   
#pragma message("STR 已经定义过了")   
#endif 
}
james@jsh:~/C_stuty/study$ cc pragma.c 
pragma.c: In function ‘main’:
pragma.c:9: note: #pragma message: STR 已经定义过了
james@jsh:~/C_stuty/study$ ./a.out 
 学习#pragma命令中message参数的使用!

       我们发现，在编译的时候会打印出m e s s a g e 参数中的信息。通过这种方式，可以在代码
中输出想要的信息，也可以看某个宏是否已经被定义过。与之前使用p r i n t f ( ) 函数实现打印
的不同之处在于：m e s s a g e 打印消息出现在编译的时候，不会出现在程序最终的运行结果中；
而p r i n t f ( ) 函数的打印消息却会出现在最终的运行结果中。有时候，我们并不希望运行结果
中出现与结果无关的信息，这时可以使用# p r a g m a 命令，选择m e s s a g e 参数来实现信息的打
印输出。

    2 ）# p r a g m a   o n c e
           如果在头文件的开头部分加入这条指令，那么就能保证头文件只被编译一次。
    3 ）# p r a g m a   h d r s t o p
          该指令表示编译头文件到此为止，后面的无需再编译了。
    4 ）# p r a g m a     p a c k ( )

int main()
{
#pragma pack(2)

    struct stu1_{
        char name[20];
        char num[20];
        int score;
        char sex;
    }stu1;

    printf("stu1 占用的内存大小为：%d\n",sizeof(stu1));
#pragma pack()

    struct stu2_{
        char name[20];
        char num[20];
        int score;
        char sex;
    }stu2;

    printf("stu2 占用的内存大小为：%d\n",sizeof(stu2));

    return 0;
}

james@jsh:~/C_stuty/study$ ./a.out 
stu1 占用的内存大小为：46
stu2 占用的内存大小为：48

        在上面的代码中，在结构体s t 1 的前面使用了# p r a g m a   p a c k ( 2 ) ，其作用是设置2 字节对齐，接下来使用了# p r a g m a   p a c k ( ) ，其作用是取消之前设置的字节对齐方式，采用默认的4字节对齐。在输出结果中，由于s t u 1 在内存中采用2 字节对齐，而s t u 2 在内存中采用4 字节对齐，所以它们输出的结果不一致。将上面的代码修改为以下的形式。

int main()
{
#pragma pack(push)
#pragma pack(2)

    struct stu1_{
        char name[20];
        char num[20];
        int score;
        char sex;
    }stu1;

    printf("stu1 占用的内存大小为：%d\n",sizeof(stu1));
#pragma pack(pop)

    struct stu2_{
        char name[20];
        char num[20];
        int score;
        char sex;
    }stu2;

    printf("stu2 占用的内存大小为：%d\n",sizeof(stu2));

    return 0;
}

        运行结果与前面代码的运行结果完全一致。看看修改的地方，在设置2 字节对齐方式之前添加了一句代码“# p r a g m a   p a c k ( p u s h ) ”，其作用是保存当前默认的字节对齐方式，而把下面原本的“# p r a g m a   p a c k ( ) ”修改为“# p r a g m a   p a c k ( p o p ) ”，其作用是恢复默认的字节对齐方式，可以看出这里代码的功能与之前代码的功能完全一致。