在许多C/C++宏定义中我们会看到宏代码包含在do while循环或者if else语句里，例如：
 
#define M(X) do { f(X); g(X); } while (0)
 
#define M(X) if (1) { f(X); g(X); } else
 
那么这种用法有什么好处呢？这种用法最大的好处是增强宏定义代码的鲁棒性，尽管使得程序稍稍变得更加复杂。为了加快项目开发进度，现在一个工程的开发越来越需要相互合作与沟通交流，不管是利用别人的代码库还是写一些头文件供别人调用，都需要程序能够按照编程者的意图运行。但是对于这里提到的宏定义来说，你并不知道别人会怎么使用你的宏，如果定义不合理就会出现一些问题，例如下面这个宏定义：
 
#define M(X) f(x); g(x)
 
如果你这样使用这个宏：
 
if (condition)
 
M(x);
 
else
 
F();
 
宏展开时会变成：
 
if (condition)
 
f(x); g(x);
 
else
 
F();
 
这样就会出现语法错误，因为else找不到对应的if语句。如果给宏添加一个大括号，则变成：
 
if (condition)
 
{f(x); g(x);};
 
else
 
F();
 
这样也会出现语法错误，因为大括号后多了分号。针对这个问题，可以利用do while(0)或者if else来解决，例如：
 
#define M(X)  do { f(X); g(X); } while (0)
 
或者：
 
#define M(X)  if (1) { f(X); g(X); } else
 
这样调用后宏展开成：
 
if (condition)
 
do { f(X); g(X); } while (0);
 
else
 
F();
 
或者：
 
if (condition)
 
if (1) { f(x); g(x); } else;
 
else
 
F();
 
这种方式利用了分号在代码中的作用，可以有效克服C预处理器的一些缺点。有些编程指南告诉你要减少使用预处理器，这里提到的一点就是他们担心的一个原因。当然对于这种情况，你也可以把M(x)单独定义为一个函数，而不是一个宏。最后需要注意的一点是宏定义要写在一行，跨行需要加反斜杠''。

大家都知道，do…while(condition)可以表示循环，但你有没有遇到在一些宏定义中可以不用循环的地方，也用到了 do…while.比如：





#define DELETE_POINTER(p)       \
    do                          \
    {                           \
        if(NULL != p)           \
            delete p;           \
        p = NULL;               \
    }while(0)




这时，do…while(0)的功能就不仅仅是循环了，这是do..while(0)的一种巧妙用法。它有以下几种功能：





1.在后面要加分号，使调用如同函数；


调用如下：





int* p = new int(5);
DELETE_POINTER(p);





2.避免if  else  不匹配；


举例说明如下：





#define PRINT_STRING(isDoc)   \
    if(isDoc)                 \
        printDoc();           




如果调用的时候如下面这样：

bool isReady = false;
    bool isDoc = true;
    if(isReady)
        PRINT_STRING(isDoc);
    else
        doOtherThing();





则此代码相当于


bool isReady = false;
    bool isDoc = true;
    if(isReady)
        if(isDoc)                
            printDoc();  
        else
            doOtherThing();




这显然与我们的本意不符。








还有其它的一些用法 ，
有人总结的很清楚了，这是不在累赘。










原文:http://www.spongeliu.com/415.html


linux内核和其他一些开源的代码中，经常会遇到这样的代码：


do{
 ...
}while(0)
这样的代码一看就不是一个循环，do..while表面上在这里一点意义都没有，那么为什么要这么用呢？


实际上，do{...}while(0)的作用远大于美化你的代码。查了些资料，总结起来这样写主要有以下几点好处：


1、辅助定义复杂的宏，避免引用的时候出错：


举例来说，假设你需要定义这样一个宏：


#define DOSOMETHING()\
               foo1();\
               foo2();
这个宏的本意是，当调用DOSOMETHING()时，函数foo1()和foo2()都会被调用。但是如果你在调用的时候这么写：


if(a]]>0)
    DOSOMETHING();
因为宏在预处理的时候会直接被展开，你实际上写的代码是这个样子的：


if(a]]>0)
    foo1();
foo2();
这就出现了问题，
因为无论a是否大于0，foo2()都会被执行，导致程序出错
。


那么
仅仅使用{}将foo1()和foo2()包起来行么
？


我们在写代码的时候都习惯在语句右面加上分号，如果在宏中使用{}，代码里就相当于这样写了：“{...};”，展开后就是这个样子：


if(a]]>0)
{
    foo1();
    foo2();
};
这样甚至不会编译通过。所以，很多人才采用了do{...}while(0);


#define DOSOMETHING() \
        do{ \
          foo1();\
          foo2();\
        }while(0)\
    
...
 
if(a]]>0)
    DOSOMETHING();
 
...
这样，宏被展开后，才会保留初始的语义。GCC提供了
Statement-Expressions
用以替代do{...}while(0); 所以你也可以这样定义宏：


#define DOSOMETHING() ({\
        foo1(); \
        foo2(); \
})
http://www.spongeliu.com/
 
2、避免使用goto对程序流进行统一的控制：


有些函数中，在函数return之前我们经常会进行一些收尾的工作，比如free掉一块函数开始malloc的内存，goto一直都是一个比较简便的方法：


int foo()
{
    somestruct* ptr = malloc(...);
 
    dosomething...;
    if(error)
    {
        goto END;
    }
 
    dosomething...;
    if(error)
    {
        goto END;
    }
    dosomething...;
 
END:
    free(ptr);
    return 0;
 
}
由于goto不符合软件工程的结构化，而且有可能使得代码难懂，所以很多人都不倡导使用，那这个时候就可以用do{}while(0)来进行统一的管理：


int foo()
{
 
    somestruct* ptr = malloc(...);
 
    do{
        dosomething...;
        if(error)
        {
            break;
        }
 
        dosomething...;
        if(error)
        {
            break;
        }
        dosomething...;
    }while(0);
 
    free(ptr);
    return 0;
 
}
这里将函数主体使用do()while(0)包含起来，使用break来代替goto，后续的处理工作在while之后，就能够达到同样的效果。


 


3、避免空宏引起的warning


内核中由于不同架构的限制，很多时候会用到空宏，在编译的时候，空宏会给出warning，为了避免这样的warning，就可以使用do{}while(0)来定义空宏：


#define EMPTYMICRO do{}while(0)
 


4、定义一个单独的函数块来实现复杂的操作：


当你的功能很复杂，变量很多你又不愿意增加一个函数的时候，使用do{}while(0);，将你的代码写在里面，里面可以定义变量而不用考虑变量名会同函数之前或者之后的重复。 











其它相关参考博文：


http://www.cnblogs.com/flying_bat/archive/2008/01/18/1044693.html


http://blog.csdn.net/chenhu_doc/article/details/856468






欢迎加入"C/C++梦之队" 学习群：226157456

宏定义，编译预处理命令，在编译预处理时即进行简单的字符串替换。
 宏定义函数和用户定义的函数在使用时有如下区别：
 1、宏函数会在编译预处理时展开，只占用编译时间，函数调用则会占用运行时间（分配单元、保存现场、值传递、返回等），每次执行都需要载入，所以执行相对于宏较慢。
 2、在函数调用时，先求出实参表达式的值，然后带入形参。而使用带参的宏只是进行简单的字符替换。
 3、函数调用是在程序运行时处理的，分配临时的内存单元；而宏展开则是在编译时进行的，在展开时并不分配内存单元，不进行值的传递处理，也没有返回值的概念。
 4、对函数中的实参和形参都要定义类型，二者的类型要求一致，如不一致，应进行类型转换；而宏不存在类型的问题，宏名无类型，只是一个符号代表，展开时代入指定的字符即可。宏定义时，字符串可以是任意类型的数据。
 5、宏函数的定义也有缺点，它容易会产生二义性。
 
do
 {
 …
 }while(0)的巧妙用法
 一：在宏函数中使用do{…}while(0)，辅助定义复杂的宏，避免引用的时候出错
 
#define DOSOMETHING() \
do \
{ \
	fool1(); \
	fool2(); \
}while(0) \
 
二：避免使用goto，实现对程序流程进行统一的控制。
 有些函数中，在renturn之前我们经常会进行一些收尾的工作，比如free掉一块函数开始malloc的内存，goto一直是一个比较简单的方法：
 
int foo()
{
	somestruct* ptr=malloc(...);
	dosomething...;
	if(error)
	{
		goto END;
	}
	dosomething...;
	if(error)
	{
		goto END;
	}
	dosomething...;
END:
	free(ptr);
	return 0;
}
 
由于goto不符合软件工程的结构化，而且有可能使得代码难懂，所以不提倡使用，那这个时候就可以用do{}while(0)来进行统一的管理：
 
int foo()
{
	somestruct* ptr=malloc(...);
	do{
		dosomething...;
		if(error)
		{
			break;
		}
		dosomething...;
		if(error)
		{
			break;
		}
		dosomething...;
	}while(0);
	free(ptr);
	return 0;
}
 
这里将函数主体使用do{}while(0)包含起来，使用break来代替goto，后续的处理工作在while之后，就能够达到同样的效果。
 
三：避免空宏引起的warning
 内核中由于不同架构的限制，很多时候会用到空宏，在编译的时候，空宏会给出warning，为了避免这样的warning，就可以使用do{}while(0)来定义空宏
 
#define EMPTYMICRO do{}while(0)
 
四：定义一个单独的函数块来实现复杂的操作：
 当你的功能很复杂时，变量很多你又不愿意增加一个函数的时候，使用do{}while(0)；将你的代码写在里面，里面可以定义变量而不用考虑变量名会同函数之前或者之后的重复。

在宏定义里面经常看到do{...}while(0)这样的语句。 

  确实很让人疑惑，do while(0)就是让代码只执行一次，何必这样呢，为什么需要用do while呢。
 

  其实，宏定义就是一个代码替换的过程。
 

  #define CODE_SEG(a) printf("sample macro:%s\n",a) 
 
 

  那么在出现了CODE_SEG(some_str)的地方，它都会在编译时被替换成printf("sample macro:%s\n",some_str)
 
 
 
 
 

  那么，我们写代码的习惯都是
 

  ...
 

  char*s="hello world";
 

  CODE_SEG(s)
 ;   //我们会习惯性地加上分号
 

  ...
 
 
 
 
 

  这时，可以编译通过，因为 
 CODE_SEG(s)
 ;  被替换成了printf("sample macro:%s\n",s)
 ;
 
 
 
 
 

  但是，如果我们的宏里面有不止一条语句，比如
 
 
 #define CODE_SEG(a) {printf("sample macro:%s\n",a);printf("done\n");} 
 
 
 这样就行不通了，因为CODE_SEG(s)
 ; 会被替换成
 
 
 {printf("sample macro:%s\n",a);printf("done\n");};  最后面这个分号回导致编译不通过
 
 
 
 
 
 
 因此，通常用do while(0)来包裹，这样就可以避免这个分号的问题
 
 
 #define CODE_SEG(a) do{printf("sample macro:%s\n",a);printf("done\n");}while(0)
 
 
  CODE_SEG(s)
 ; 会被替换成
 
 
 do{printf("sample macro:%s\n",a);printf("done\n");}while(0);
 
 最后的这个分号此时就是恰到好处了，编译通过。
 
 
 
 
 
 
 如果你是一名C程序员，你肯定很熟悉宏，它们非常强大，如果正确使用可以让你的工作事半功倍。然而，如果你在定义宏时很随意没有认真检查，那么它们可能使你发狂，浪费N多时间。在很多的C程序中，你可能会看到许多看起来不是那么直接的较特殊的宏定义。下面就是一个例子：
 
 
 
 
  
 
   
 
       

         1
       
 
       

         2
       
 
 
       
 
        
 
         #define __set_task_state(tsk, state_value)      \
        
 
        
 
             
         do 
         { (tsk)->state = (state_value); } 
         while 
         (0)
        
 
       
 
 
  
 
 
 
 
 在Linux内核和其它一些著名的C库中有许多使用do{...}while(0)的宏定义。这种宏的用途是什么？有什么好处？
 
 Google的Robert Love（先前从事Linux内核开发）给我们解答如下：
 
 
 
do{...}while(0)在C中是唯一的构造程序，让你定义的宏总是以相同的方式工作，这样不管怎么使用宏（尤其在没有用大括号包围调用宏的语句），宏后面的分号也是相同的效果。
 
 
 这句话听起来可能有些拗口，其实用一句话概括就是：使用do{...}while(0)构造后的宏定义不会受到大括号、分号等的影响，总是会按你期望的方式调用运行。
 
 例如：
 
 
 
 
  
 
   
 
       

         1
       
 
 
       
 
        
 
         #define foo(x) bar(x); baz(x)
        
 
       
 
 
  
 
 
 
 
 然后你可能这样调用：
 
 
 
 
  
 
   
 
       

         1
       
 
 
       
 
        
 
         foo(wolf);
        
 
       
 
 
  
 
 
 
 
 这将被宏扩展为：
 
 
 
 
  
 
   
 
       

         1
       
 
 
       
 
        
 
         bar(wolf); baz(wolf);
        
 
       
 
 
  
 
 
 
 
 这的确是我们期望的正确输出。下面看看如果我们这样调用：
 
 
 
 
  
 
   
 
       

         1
       
 
       

         2
       
 
 
       
 
        
 
         if 
         (!feral)
        
 
        
 
             
         foo(wolf);
        
 
       
 
 
  
 
 
 
 
 那么扩展后可能就不是你所期望的结果。上面语句将扩展为:
 
 
 
 
  
 
   
 
       

         1
       
 
       

         2
       
 
       

         3
       
 
 
       
 
        
 
         if 
         (!feral)
        
 
        
 
             
         bar(wolf);
        
 
        
 
         baz(wolf);
        
 
       
 
 
  
 
 
 
 
 显而易见，这是错误的，也是大家经常易犯的错误之一。
 
  
 
 几乎在所有的情况下，期望写多语句宏来达到正确的结果是不可能的。你不能让宏像函数一样行为——在没有do/while(0)的情况下。
 
 如果我们使用do{...}while(0)来重新定义宏，即：
 
 
 
 
  
 
   
 
       

         1
       
 
 
       
 
        
 
         #define foo(x) do { bar(x); baz(x); } while (0)
        
 
       
 
 
  
 
 
 
 
 现在，该语句功能上等价于前者，do能确保大括号里的逻辑能被执行，而while(0)能确保该逻辑只被执行一次，即与没有循环时一样。
 
 对于上面的if语句，将会被扩展为：
 
 
 
 
  
 
   
 
       

         1
       
 
       

         2
       
 
 
       
 
        
 
         if 
         (!feral)
        
 
        
 
             
         do 
         { bar(wolf); baz(wolf); } 
         while 
         (0);
        
 
       
 
 
  
 
 
 
 
 从语义上讲，它与下面的语句是等价的：
 
 
 
 
  
 
   
 
       

         1
       
 
       

         2
       
 
       

         3
       
 
       

         4
       
 
 
       
 
        
 
         if 
         (!feral) {
        
 
        
 
             
         bar(wolf);
        
 
        
 
             
         baz(wolf);
        
 
        
 
         }
        
 
       
 
 
  
 
 
 
 
 这里你可能感到迷惑不解了，为什么不用大括号直接把宏包围起来呢？为什么非得使用do/while(0)逻辑呢？
 
 例如，我们用大括号来定义宏如下：
 
 
 
 
  
 
   
 
       

         1
       
 
 
       
 
        
 
         #define foo(x)  { bar(x); baz(x); }
        
 
       
 
 
  
 
 
 
 
 这对于上面举的if语句的确能被正确扩展，但是如果我们有下面的语句调用呢：
 
 
 
 
  
 
   
 
       

         1
       
 
       

         2
       
 
       

         3
       
 
       

         4
       
 
 
       
 
        
 
         if 
         (!feral)
        
 
        
 
             
         foo(wolf);
        
 
        
 
         else
        
 
        
 
             
         bin(wolf);
        
 
       
 
 
  
 
 
 
 
 宏扩展后将变成：
 
 
 
 
  
 
   
 
       

         1
       
 
       

         2
       
 
       

         3
       
 
       

         4
       
 
       

         5
       
 
       

         6
       
 
 
       
 
        
 
         if 
         (!feral) {
        
 
        
 
             
         bar(wolf);
        
 
        
 
             
         baz(wolf);
        
 
        
 
         };
        
 
        
 
         else
        
 
        
 
             
         bin(wolf);
        
 
       
 
 
  
 
 
 
 
 大家可以看出，这就有语法错误了。
 
  
 
 总结：Linux和其它代码库里的宏都用do/while(0)来包围执行逻辑，因为它能确保宏的行为总是相同的，而不管在调用代码中使用了多少分号和大括号。
 
参考： 
 http://www.360doc.com/content/12/0405/16/8302596_201146109.shtml
 
 
 http://www.cnblogs.com/lanxuezaipiao/p/3535626.html