宏 介绍

最近在看 深入浅出MFC时，遇到了一大堆莫明其妙的宏定义，看的是一头雾水。今天在网上照料篇关于宏的文章， 希望对各位与我有同样经历的同仁有所帮助。

 

1.   宏定义的格式  
   
          宏定义的一般格式是：  
   
                  #define     标识符     字符串  
   
  其中，标识符和字符串之间用空格隔开。标识符又称宏名，为了区别于一般变量，通常用英文大写字母表示；字符串又称宏体，可以是常量、关键字、语句、表达式，还可以是空白。于是，宏定义又可以描述成：  
   
                  #define     宏名     宏体  
   
          其作用是把标识符定义为字符串。在进行编译预处理时，编译 系统 就能够把程序中出现的标识符，一律用字符串去替换，然后再对替换处理后的源程序进行编译。把宏名置换为宏体的过程，叫做宏展开。例如  
   
                  #define   YES   1  
   
                  #define   NO     0  
   
          该宏定义就是我们前面多次用到的定义符号常量的形式：将YES定义为1，NO   定义为0。  
   
          符号常量经过定义后，就可以在程序中作为常量 使用 。例如：  
   
                  if   (x==YES)  
   
                        printf(%d/n,YES);  
   
                  else   if   (x==No)  
   
                        printf(%d/n,NO);  
   
  经过编译预处理后，程序中的符号常量用定义它们的常数去替换，得到如下的源程序：  
   
                  if   (x==1)  
   
                      printf(%d/n,1);  
   
                  else   if   (x==0)  
   
                      printf(%d/n,0);  
   
  又如，定义了  
   
                  #define   EMS   standard   error   on   input/n  
   
  后，程序中出现的  
   
                  printf(EMS);  
   
  经预处理后被替换为  
   
                  printf(standard   error   on   input/n);  
   
          但是，宏名如果出现在字符串中，编译预处理不会对它进行替换。例如程序段  
   
                  char   *ps  
   
                  ps=x==YES;   printf(%s/n,ps);  
   
  变量ps右边出现的YES不会被置换，输出结果为“x==YES”而不是“x==1”。  
   
          除了常数外，宏体还可以是表达式或空。例如：  
   
                  #define   REG3  
   
  在这个宏定义中，只有宏名，没有宏体。此时，REG3被定义为符号常量0。  
   
          一个#define只能定义一个宏，若需要定义多个宏就要用多个#define。  
   
          2.   宏定义的嵌套  
   
          嵌套的宏定义，就是用定义过的宏名去定义另一个宏名。例如：  
   
                  #define   WIDTH   80  
   
                  #define   LENGTH   (WIDTH+40)  
   
  在第二个宏定义中，使用了前面定义过的宏名WIDTH。在编译预处理时，程序中所有的WIDTH都被80所替换，所有的LENGTH又被(80+40)替换。如果程序中出现了如下语句：  
   
                  var=LENGTH*20;  
   
  经过替换以后变为：  
   
                  var=(80+40)*20;   /*   var的值为2400   */  
   
  但是如按以下方式定义：  
   
                  #define   WIDTH   80  
   
                  #define   LENGTH   WIDTH+40  
   
                  var=LENGTH*20;  
   
  则经过编译预处理后变成  
   
                  var=80+40*20;       /*   var的值为160   */  
   
          就是说，宏替换只是简单地用定义的宏体去替换宏名而不进行任何计算。因此，宏定义中若出现表达式时，园括号的有无， 效果 明显不同。为了保证定义在置换后仍保持正确的运算顺序，经常在定义中使用必要的圆括号将字符串括起来。  
   
          3.   宏定义的功能  
   
          (1)   定义符号常量  
   
          定义符号常量是宏定义的一种 应用 。前面定义的都是符号常量，它可以提高程序的运行效率，因为编译程序处理常数的速度比变量快；使用变量来代替常量，会使程序不易读，一不小心极可能修改变量的值；使用符号常量还可以方便地改变其值并达到一改全改。事实上我们在前几章中已大量用到这类符号常量。例如，用符号常量作为数组的维界说明，可以增加程序的通用性。  
   
          (2)   定义函数  
   
          定义一个简单的函数是宏定义的另一个应用。这时，宏名带有一个或多个 参数 。带参数的宏定义的一般格式为：  
   
                  #define     标识符(形参表)     宏体  
   
  例如：  
   
                  #define   POWER(X)   ((X)*(X))  
   
  其中，POWER(X)   称为带参数的宏，x是它的形式参数；((x)*(x))为宏体。在此定义之后，便可以在程序中用POWER(X)来进行表达式((x)*(x))的计算。形参的使用方法也类似于函数的形参。例如  
   
                  int   i;  
   
                  for   (i=0;i<100;i++)  
   
                      printf(%d     ,POWER(i));  
   
  可打印0～99的平方。  
   
          在程序设计中，经常把那些反复使用的运算表达式甚至某些操作，定义为带参数的宏。这样，一方面使程序更加简洁，另一方面，可以使运算的意义更加明显。在定义带参数的宏时，对形参的数量没有限制。下面给出几个常用的带参数的宏的实例：  
   
                  #define   MAX(x,y)   ((x>y)?x:y)                           求x和y中的较大的一个  
   
                  #define   ABS(x)   ((x>=0)?   x:0-x)                       求x的绝对值  
   
                  #define   PERCENT(x,y)   (100.0*x/y)                   求x除以y的百分数值  
   
                  #define   ISODD(x)   ((x%2==1)?1:0)                     判断x是否为奇数  
   
                  #define   SWAP(t,x,y)   {   t=x;   x=y;   y=t;   }       交换x和y的值  
   
          注意，带参数的宏与函数在使用形式上虽有某些相似之处，但二者在本质上是不同的：  
   
          (1)   在程序控制上，函数的调用需要进行函数控制的转移；使用带参数的宏，则仅仅是表达式的运算。  
   
          (2)   带参数的宏，一般是一个运算表达式，所以它不象函数那样有固定的数据类型。宏的数据类型，可以说是它的表达式运算结果的类型，随着使用的实参数不同，运算结果呈现不同的数据类型。例如  
   
                  float   x;  
   
                  for   (x=0;x<100;x+=1)  
   
                      printf(%f     ,POWER(x));  
   
  将得到实型值。  
   
          (3)   在调用函数时，对使用的实参有一定的数据类型限制；而带参的宏的实参，可以是任意数据类型。  
   
          (4)   函数调用时，存在着从实参向形参传递数据的过程，而带参数的宏不存在这种过程。  
   
          尽管带参数的宏和函数一样，可以作为程序模块而用于模块化程序设计中，但是，使用带参数的宏，有如下独有的特点：  
   
          (1)   程序中使用带参数的宏，由于不存在控制的转移和参数的传递，因而可以得到较高的程序执行速度；但是由于定义代码的反复使用而使程序变大，因而在对源程序进行编译时，要花费较多的 时间 。  
   
          (2)   带参数的宏，除了使用运算表达式定义之外，还可以使用函数。在标准函数库中，经常使用这种形式。例如：  
   
                  #define   getchar()   fgetc(stdin)        
   
  在这里，getchar()实质上是用另一个函数定义的宏，这样定义的宏替换与定义它的函数，在性质上是相同的。  
   
          (3)   宏替换不象函数调用一样，要进行参数传递，保存现场、返回函数值等操作。因此，对简短的表达式以及调用频繁、要求快速响应的场合，采用宏替换较好些。  
   
          (4)   宏替换只是简单的字符替换而不进行计算，因而一些过程是不能用宏替换去代替函数调用的(例如递归调用)。  
   
          (5)   宏定义如果使用不当，会产生不易觉察的错误。  
   
          例8.1     比较打印整数1～10的平方的两个程序。  
   
          ①采用函数调用的程序  
   
                  #include    
   
                  main()  
   
                      {   int   i=1;  
   
                          while(i<=10)  
   
                              printf(%d/n,square(i++));}  
   
                  square(int   n)  
   
                      {   return   (n*n);}  
   
          ②采用宏定义的程序  
   
                  #define   SQUARE(n)   ((n)*(n))  
   
                  main()  
   
                      {   int   i=1;  
   
                          while   (i<=10)  
   
                              printf(%d/n,SQUARE(i++));}  
   
   
   
   
   
          运行这两个程序，得到的结果分别是：(1,4,9,16,25,36,49,64,81,100)和     (2,12,30,56,90)。  
   
          很明显，第一个程序是成功的，而第二个程序没有达到预期的目的。其原因是：在第二个程序中，经宏替换后，printf()函数语句被置换为：  
   
                  printf(%d/n,(i++)*(i++));  
   
          Turbo   C编译系统在处理函数实参求值时，采用自右而左逐项求值，而i++是“先使用，再加1”。因此，当i的初值为1时，在第一次循环中，先处理右边的(i++)，即用i的原值1作为右边(i++)的值，该i经自加后变成2作为左边(i++)的i原值，结果是2*1，计算后左边(i++)的i值自加1变成3，再参加第二次循环。因此在第二次循环中进行的是3*4的运算，然后i   变成5。在第三次循环中进行的是5*6的运算。最后进行9*10的运算。  
   
            从上例可以看出，使用带参数的宏替换，引入i++的副作用，而采用函数调用的程序时，则不会出现上述问题。因为在函数调用中i++作为实参，只出现一次；而在宏替换后，i++出现两次。  
   
     
   
  8.1.2   宏定义的解除  
   
   
          在程序开头使用的宏定义具有全局意义。如果我们想把宏定义的作用域限制在程序的某个范围内，可以使用#undef来解除已有的宏定义。其一般形式为：  
   
                  #undef   宏名  
   
  其中，宏名是在此之前已定义过的。#undef的功能是解除前已定义的宏，使之不再起作用。例如：  
   
                    #define   PDP   1  
   
                    #define   MUL(x)     ((x)*(x))  
   
                          ...  
   
                    #undef   PDP  
   
                    #undef   MUL  
   
  使宏PDP和MUL(x)只在#undef之前的程序中有效，在#undef之后就不能再使用这两个宏。注意，解除带参数的宏定义时，只需给出宏名，而不必给出宏体。  
   
          程序中将#define   和#undef配合使用，就可以把宏定义的使用限制在二者之间的范围内，因此也称之为局部宏定义。  
   
          #undef的另一个作用是重新进行宏定义。C语言规定：符号常量和带参数的宏都不能重复定义，即程序中不能定义同名的宏。例如，在程序开头定义了SIZE是256，到程序的另一个地方需要定义SIZE是512，使用  
   
                  #define   SIZE   256  
   
                          ...  
   
                  #define   SIZE   512  
   
  是不允许的。但是，如果在定义SIZE为512之前，用  
   
                  #undef   SIZE    
   
  来解除原先的定义，就可以定义SIZE为512。  
   
          在实际应用时，由多个源文件组成的程序，在不同的源文件中可能会出现同一个宏名被定义为不同的宏体。若将这些源文件合并在一起时，就会出现重复宏定义的错误。可以在每个源文件的末尾把使用过的宏定义均用#undef解除。