macro again, hehe, more details and in chinese

说到宏，恐怕大家都能说出点东西来：一种预处理，没有分号（真的吗？）。然后呢？
嗯.......茫然中......
好吧，我们就从这开始说起。
最常见的宏恐怕是#include了，其次就是#define还有.......
还是从宏的用途分类吧：

1、#include 主要用于包含引用文件，至今其地位无人能替代；

2、注释掉代码。例如：
   #if 0
   .......
   #endif;
   这种机制是目前注释掉代码的最佳选择，为摩托罗拉公司员工所普遍采用；

3、代码版本管理。例如：
   #ifdef DEBUG
   file://调试版本
   #else
   file://非调试版本
   #endif;

4、声明宏。例如：
   #define DECLARE_MESSAGE(x) x();~x()   file://有没有分号？哈哈
   //........
   class A
   {
   public:
           DECLARE_MESSAGE(A);
   ..............
   }
   想起什么了，呵呵：）对,VC里面有好多这样的东东，有空我会写《我的VC历程》，到
时候会把VC里的各种宏详细的解释一下，那可是一个庞大的工程：）

5、符号常量。例如：
   #define PI 3.14159

6、内联函数。例如：
   #define CLEAR(x) ((x)=0)

7、泛型函数。例如:
   #define ABS(x) ((x)>0? (x):-(x))
   x=3 没问题！ x=1.3 也没问题！
   如果是这样呢:
   #include <iostream.h>
   #define A(x) ((x)>0? (x):-(x))

   void main()
   {
 int i=-1;
 cout<<A(1)<<endl;
 cout<<A(++i)<<endl;
   }
   有问题了，不过以后再说，大概讲const or inline 时会说的：）

8、泛型类型。例如：
   #define Stack(T)  Stack__ ##T
   #define Stackdeclare(T)  class Stack(T) {.....}
   Stackdeclare(int);
   Stackdeclare(char);
   .......
   Stack(int) s1;
   Stack(char) s2;

9、语法扩展。例如：
   Set<int> s;//假设Set为一个描述集合的类
   int i;
   FORALL(i,s);
   .......

  宏最大的问题便是易引起冲突，例如：
  libA.h:
   #define MACRO stuff
  同时：
  libB.h:
   #define MACRO stuff
  下面我们对他们进行引用：
  user.cpp:
   #include "libA.h"
   #include "libB.h"
  .............
   糟糕，出现了重定义！
  还有一种冲突的可能：
  libB.h:（没有定义宏MACRO)
  class x   { void MACRO();  ...........};
  那么程序运行期间，libA.h中的宏讲会改变libB.h中的成员函数的名字，导致不可预料
的结果。
  宏的另一个问题，便是如7中出现的问题，如果你把7中的x设为"a"，程序也不会给出任
何警告，所以他是不安全的。
  针对以上的问题，我们说：
  1、尽可能的少用公用宏,能替换掉就替换掉；
  2、对那些不能替换的宏，使用命名约定；

   1、符号常量预处理程序我们可以用const or enum 来代替：
      const int TABLESIZE=1024;
      enum {  TABLESIZE=1024  }；

   2、非泛型内联函数的预处理程序可以使用真正的内联函数来代替：
      inline void clear(int& x) {x=0;}
      奥，对了，还有这样一种情况：
      #define  CONTROL(c)  ((c)-64)
      ..........
      switch(c)
      {
         case CONTROL("a") :  ......
         case CONTROL("b") :  ......
         case CONTROL("c") :  ......
         case CONTROL("d") :  ......
         ..........
      }
      这时候就不能单独使用内联函数来取代了，因为case标签禁止函数调用，我们只好
做如下转换：
      inline char control(char c) { return c+64; }
      ...........
      switch(control(c))
      {
        case "a":..... 
        case "b":.....
        case "c":.....
        case "d":.....
        ........
      }
      当然这样做是以牺牲时间作为代价的（你想想为什么:)）

   3、对于泛型预处理程序，我们可以用函数模板或类默板来代替：
      template<class T>
      T ABS(const T& t) { return t>0 ? t : -t;  }
      template<class T>
      Class Stack   {  ............   };

   4、最后对于语法扩展程序几乎都可以用一个或多个C++类代替：
      Set<int> s;
      int i;
      Set_iter<int> iter(s);
      while(iter.next(i))
      ...........
      与使用宏相比，我们只是牺牲了一点程序的简洁性而已。

   当然并不是所有的宏都能替换（我们也并不主张替换掉所有的宏！），对于不能替换的
宏，我们应该对他们实行命名约定，例如：
     #define COMPANY_XYZ_LIBABC_MACRO stuff
    同时我们也要采取一定的方法，进行预防：
     #ifndef COMPANY_XYZ_LIBABC_MACRO
     #define COMPANY_XYZ_LIBABC_MACRO stuff
     #endif
    当然，在程序库实现内部定义的宏没有这个约束：
     my.cpp:
     #define MACRO stuff
     ........

   我们给出几个常见的宏：  
   #define  A(x)    T_##x
   #define  Bx)    #@x
   #define  Cx)    #x
   我们假设：x=1，则有：
   A(1)=======T_1
   B(1)======"1"
   C(1)======"1"
   还有一个比较常见的宏：_T
   TCHAR tStr[] = _T("t code");
   _T宏的作用就是转换成TCHAR。  

VC中预处理指令与宏定义的妙用（1）

作者： 刘巍
Monday, June 24 2002 11:28 AM
刚接触到MFC编程的人往往会被MFC 向导生成的各种宏定义和预处理指令所吓倒，但是预处理和宏定义又是C语言的一个强大工具。使用它们可以进行简单的源代码控制，版本控制，预警或者完成一些特殊的功能。

一个经典的例子

使用预处理与宏定义最经典的例子莫过于加在一个头文件中以避免头文件被两次编译。试想这种的情况，有一个文件headerfile.h 它被包含在headerfile1.h中，同时在headerfile2.h 中也被包含了，现在有一个CPP文件，implement.cpp 包含了headerfile1.h 和headerfile2.h：

#include “headerfile1.h”
#include “headerfile2.h”

假设headerfile.h 中定义了一个全局变量 iglobal 。

int iglobal;

在编译的时候编译器两次编译headerfile，也就会发现iglobal被定义了两次，这时就会发生变量重定义的编译错误。

传统的解决办法是使用#ifdef 以及#endif 来避免头文件的重复编译，在上面的例子中，只需要加上这么几行：

#ifndef smartnose_2002_6_21_headerfile_h
#define smartnose_2002_6_21_headerfile_h

int iglobal;

#endif

仔细的考虑上面的宏定义，会发现当编译器编译过一次headerfile.h以后，smartnose_2002_6_21_headerfile_h 这个宏就被定义了，以后对headerfile.h的编译都会跳过int iglobal 这一行。当然smartnose_2002_6_21_headerfile_h 这个宏是可以任意定义的，但是这个宏本身不能和其它文件中定义的宏重复，所以MFC在自动生成的文件中总是使用一个随机产生的长度非常长的宏，但我觉得这没有必要，我建议在这个宏中加入一些有意义的信息，比方作者，文件名，文件创建时间等等，因为我们有时候会忘记在注释中加入这些信息。

在VC.Net 中我们不会再看见这些宏定义了，因为在这里会普遍使用一个预处理指令：

#pragma once

只要在头文件的最开始加入这条指令就能够保证头文件被编译一次，这条指令实际上在VC6中就已经有了，但是考虑到兼容性并没有太多的使用它。

源代码版本控制
当我们为许多平台开发多个版本的时候预编译指令和宏定义也能够帮我们的忙。假设我们现在为WINDOWS 和LINUX开发了一套软件，由于这两种系统的不同，我们不得不在程序控制源代码的版本。比方内存的分配，我们可以在LINUX上使用标准C的malloc 函数，但是我们希望在WINDOWS上使用HeapAlloc API。下面的代码演示了这种情况：

main()

{
………………..
#ifdef _WINDOWS_PLATFORM
    HeapAlloc(5);
#else
    malloc(5);
#endif
………………..

}

当我们在WINDOWS 平台上编译此程序的时候，只需要定义_WINDOWS_PLATFORM这个宏，那么HeapAlloc这条语句就能够起作用了。这样就能够让我们在同一个文件中为不同的平台实现不同版本的代码，同时保持程序的良好结构。在许多情况下，我们还可以为一个方法使用不同的算法，然后用宏定义来针对不同的情况选择其中的一个进行编译。这在MFC应用程序中是使用得最多的。最明显的就是文件中经常存在的

#ifdef _DEBUG

…………………….some code………..

#endif

这样的代码，这些代码在应用程序的调试版（DEBUG）中会发挥其作用。

#Pragma 指令
在所有的预处理指令中，#Pragma 指令可能是最复杂的了，它的作用是设定编译器的状态或者是指示编译器完成一些特定的动作。其格式一般为

#Pragma Para

其中Para 为参数，下面来看一些常用的参数。

message 参数。 Message 参数是我最喜欢的一个参数，它能够在编译信息输出窗口中输出相应的信息，这对于源代码信息的控制是非常重要的。其使用方法为：

#Pragma message(“消息文本”)

当编译器遇到这条指令时就在编译输出窗口中将消息文本打印出来。

当我们在程序中定义了许多宏来控制源代码版本的时候，我们自己有可能都会忘记有没有正确的设置这些宏，此时我们可以用这条指令在编译的时候就进行检查。假设我们希望判断自己有没有在源代码的什么地方定义了_X86这个宏可以用下面的方法

#ifdef _X86

#Pragma message(“_X86 macro activated!”)

#endif

当我们定义了_X86这个宏以后，应用程序在编译时就会在编译输出窗口里显示“_X86 macro activated!”。我们就不会因为不记得自己定义的一些特定的宏而抓耳挠腮了。

另一个使用得比较多的pragma参数是code_seg。格式如：

#pragma code_seg( ["section-name"[,"section-class"] ] )

它能够设置程序中函数代码存放的代码段，当我们开发驱动程序的时候就会使用到它。

最后一个比较常用的就是上面所说的#pragma once 指令了。

VC预定义的宏
在VC中有一类宏并不是由用户用#define语句定义的，而是编译器本身就能够识别它们。这些宏的作用也是相当大的。让我们来看第一个，也是MFC中使用得最频繁的一个:__FILE__ 。

当编译器遇到这个宏时就把它展开成当前被编译文件的文件名。好了，我们马上就可以想到可以用它来做什么，当应用程序发生错误时，我们可以报告这个错误发生的程序代码在哪个文件里，比方在文件test.cpp中有这样的代码：

try
{
    char * p=new(char[10]);
}
catch(CException *e )
{
    TRACE(“ there is an error in file: %s/n”,__FILE__);
}

在程序运行的时候，如果内存分配出现了错误，那么在调试窗口中会出现there is an error in file: test.cpp 这句话，当然，我们还可以把这个错误信息显示在别的地方。

如果我们还能够记录错误发生在哪一行就好了，幸运的是，与__FILE__宏定义一样，还有一个宏记录了当前代码所在的行数，这个宏是__LINE__。使用上面的两个宏，我们可以写出一个类似于VC提供的ASSERT语句。下面是方法

#define MyAssert(x) /
  if(!(x)) /
        MessageBox(__FILE__,__LINE__,NULL,MB_OK);

我们在应用程序中可以象使用ASSERT语句一样使用它，在错误发生时，它会弹出一个对话框，其标题和内容告诉了我们错误发生的文件和代码行号，方便我们的调试，这对于不能使用ASSERT语句的项目来说是非常有用的。

除了这两个宏以外，还有记录编译时间的__TIME__，记录日期的__DATE__，以及记录文件修改时间的__TIMESTAMP__宏。

使用这些预定义的宏，我们几乎可以生成和VC能够生成的一样完整的源代码信息报表。

结论
翻开MFC和Linux的源代码，宏定义几乎占据了半边天，消息映射，队列操作，平台移植，版本管理，甚至内核模块的拆卸安装都用宏定义完成。毫不夸张的说，有些文件甚至就只能看见宏定义。所以学习宏定义，熟练的使用宏定义对于学习C语言乃至VC都是非常关键的。

--------------------------------------------------------------------------------
刘巍 － 高级程序员、软件设计师，精通VC,VB,COM,PLATFORM SDK,DDK，TCP/IP。独立开发过多种windows应用程序，WDM USB驱动程序，网络应用程序。熟悉加密技术，熟悉LINUX下的C/C++开发。

VC 中预处理指令与宏定义的妙用（2）

作者： 刘巍
Tuesday, July 9 2002 3:15 PM
在上一篇文章中，我演示了几个常用的宏定义和预处理指令，但可以说这些都是相当常规的技巧。下面要介绍的宏定义与预处理指令的用法也是ATL，MFC以及LINUX中使用得比较多的非常重要的技巧。

## 连接符与# 符

##连接符号由两个井号组成，其功能是在带参数的宏定义中将两个子串(token)联接起来，从而形成一个新的子串。但它不可以是第一个或者最后一个子串。所谓的子串(token)就是指编译器能够识别的最小语法单元。具体的定义在编译原理里有详尽的解释，但不知道也无所谓。同时值得注意的是#符是把传递过来的参数当成字符串进行替代。下面来看看它们是怎样工作的。这是MSDN上的一个例子。

假设程序中已经定义了这样一个带参数的宏：

#define paster( n ) printf( "token" #n " = %d", token##n )
同时又定义了一个整形变量：

int token9 = 9;
现在在主程序中以下面的方式调用这个宏：

paster( 9 );
那么在编译时，上面的这句话被扩展为：

printf( "token" "9" " = %d", token9 );
注意到在这个例子中，paster(9);中的这个”9”被原封不动的当成了一个字符串，与”token”连接在了一起，从而成为了token9。而#n也被”9”所替代。

可想而知，上面程序运行的结果就是在屏幕上打印出token9=9

在ATL的编程中，我们查看它的源代码就会经常看见这样的一段：

#define IMPLEMENTS_INTERFACE(Itf) /
{&IID_##Itf, ENTRY_IS_OFFSET,BASE_OFFSET(_ITCls, Itf) },
我们经常不假思索的这样使用它：
……
IMPLEMENTS_INTERFACE(ICat)
……

实际上IID_ICat 已经在别的地方由ATL向导定义了。当没有向导的时候，你只要遵循把IID_加在你的接口名前面来定义GUID的规则就也可以使用这个宏。在实际的开发过程中可能很少用到这种技巧，但是ATL使用得如此广泛，而其中又出现了不少这样的源代码，所以明白它是怎么一回事也是相当重要的。我的一个朋友就是因为不知道IMPLEMENTS_INTERFACE宏是怎么定义的，而又不小心改动了IID_ICat的定义而忙活了一整天。

LINUX的怪圈

在刚开始阅读LINUX的时候有一个小小的宏让我百思不得其解：

#define wait_event(wq,condition) /
do{ /
    if(condition) /
        break; /
        __wait_event(wq,condition); /
}while(0)

这是一个奇怪的循环，它根本就只会运行一次，为什么不去掉外面的do{..}while结构呢？我曾一度在心里把它叫做“怪圈”。原来这也是非常巧妙的技巧。在工程中可能经常会引起麻烦，而上面的定义能够保证这些麻烦不会出现。下面是解释：

假设有这样一个宏定义

#define macro(condition) /

if(condition) dosomething();

现在在程序中这样使用这个宏：

if(temp)
    macro(i);
else
    doanotherthing();

一切看起来很正常，但是仔细想想。这个宏会展开成：

if(temp)
    if(condition) dosomething();
else
    doanotherthing();

这时的else不是与第一个if语句匹配，而是错误的与第二个if语句进行了匹配，编译通过了，但是运行的结果一定是错误的。

为了避免这个错误，我们使用do{….}while(0) 把它包裹起来，成为一个独立的语法单元，从而不会与上下文发生混淆。同时因为绝大多数的编译器都能够识别do{…}while(0)这种无用的循环并进行优化，所以使用这种方法也不会导致程序的性能降低。

几小小的警告

正如微软声称的一样，宏定义与预编译器指令是强大的，但是它又使得程序难以调试。所以在定义宏的时候不要节省你的字符串，一定要力争完整的描述这个宏的功能。同时在定义宏的时候如有必要（比方使用了if语句）就要使用do{…}while(0)将它封闭起来。在宏定义的时候一定要注意各个宏之间的相互依赖关系，尽量避免这种依赖关系的存在。下面就有这样一个例子。

设有一个静态数组组成的整型队列，在定义中使用了这样的方法：

int array[]={5, 6, 7, 8};

我们还需要在程序中遍历这个数组。通常的做法是使用一个宏定义

#define ELE_NUM 4
…………………………..
……………………………..

for(int I=0;I<ELE_NUM;I++)
{
    cout<<array[I];
}

由于某种偶然的原因，我们删除了定义中的一个元素，使它变成：

array[]={5,6,7}

而却忘了修改ELE_NUM的值。那么在上面的代码中马上就会发生访问异常，程序崩溃。然后是彻夜不眠的调试，最后发现问题出在这个宏定义上。解决这个问题的方法是不使用

array[]={….}这样的定义，而显式的申明数组的大小：

array[ELE_NUM]={….}

这样在改动数组定义的时候，我们就不会不记得去改宏定义了。总之，就是在使用宏定义的时候能够用宏定义的地方统统都用上。

我发现的另一个有趣的现象是这样的：

假设现在有一个课程管理系统，学生的人数用宏定义为

#define STU_NUM 50

而老师的人数恰好也是50人，于是很多人把所有涉及到老师人数的地方通通用上STU_NUM这个宏。另一个学期过去，学生中的一个被开除了，系统需要改变。怎么办呢？简单的使用#define STU_NUM 49 么？如果是这样，一个老师也就被开除了，我们不得不手工在程序中去找那些STU_NUM宏然后判断它是否是表示学生的数目，如果是，就把它改成49。天哪，这个宏定义制造的麻烦比使用它带来的方便还多。正确的方法应该是为老师的数目另外定义一个宏：

#define TEA_NUM 50

当学生的数目改变以后只要把STU_NUM 定义为49就完成了系统的更改。所以，当程序中的两个量之间没有必然联系的时候一定不要用其中的一个宏去替代另一个，那只会让你的程序根本无法改动。

最后，建议C/C++语言的初学者尽可能多的在你的程序中使用宏定义和预编译指令。多看看MFC，ATL或者LINUX的源代码，你会发现C语言强大的原因所在。

--------------------------------------------------------------------------------
刘巍 － 高级程序员、软件设计师，精通VC,VB,COM,PLATFORM SDK,DDK，TCP/IP。独立开发过多种windows应用程序，WDM USB驱动程序，网络应用程序。熟悉加密技术，熟悉LINUX下的C/C++开发。