do{}while(0)的用法

作者：好好编程
来源：CSDN
原文：https://blog.csdn.net/qw8880000/article/details/80198581
版权声明：本文为博主原创文章，转载请附上博文链接！

1、使用do{}while(0)来编写单进单出函数。

在一些函数里，我们希望在函数的入口与出口处做一些配对的操作，比如内存的申请与释放、文件的打开与关闭、加锁与解锁等。在这样的函数里可以设计成单进单出，好处是后期维护不容易出错。

假设我们有一个函数，里面的操作存在竞争，那我们为它加上锁的机制，代码可能是这样：

int data_process(const char* data)
{
    lock(mutex);

    // 异常判断1
    if(!condition1) {
        unlock(mutex);
        return -1;
    }

    // 异常判断2
    if(!condition2) {
        unlock(mutex);
        return -1;
    }

    data_convert(data);
    ...

    unlock(mutex);
    return 0;
}

上述函数的写法不是单进单出，即有很多出口，于是每个出口处都必须记得解锁。如果换成单进单出的写法，上述情况会变得简单一些，只需要记得在最后出口处解锁即可。

int data_process(const char* data)
{
    int ret = -1;
    lock(mutex);

    // do{}while(0) 函数体内不允许使用return
    do {
        // 异常判断1
        if(!condition1) {
            ret = -1;
            break;
        }

        // 异常判断2
        if(!condition2) {
            ret = -1;
            break;
        }

        data_convert(data);
        ...
        ret = 0;

    } while(0);

    unlock(mutex);
    return ret;
}

改进后的代码只需要记得不要在do{}while(0)代码块里使用return，而原先的代码需要在每一个return处检查是否解锁。个人认为还是do{}while(0)方法比较好记，而且当团队里的成员对do{}while(0)的用法熟悉了以后，一但看到此结构出现便可以条件反射般的意识到此函数有机关，使用return需谨慎。

2、避免goto语句：

#defien N 10
bool Execute()
{
   // 分配资源
   int *p = (int *)malloc(N * sizeof(int));
   bool bOk = true;

   // 执行并进行错误处理
  bOk = func1();
  if(!bOk) 
  {
     free(p);   
     p = NULL;
     return false;
  }
  bOk = func2();
  if(!bOk) 
  {
     free(p);   
     p = NULL;
     return false;
  }
  bOk = func3();
  if(!bOk) 
  {
     free(p);    
     p = NULL;
     return false;
  }
  // ..........
  // 执行成功，释放资源并返回
   free(p);   
   p = NULL;
   return true;
}

这里最大的问题是代码冗余，每增加一个操作，就要做相应的错误处理，非常不灵活，于是想到了一下的goto：

 #defien N 10
 
 bool Execute()
 {
    // 分配资源
    int *p = (int *)malloc(N * sizeof(int));
    bool bOk = true;
 
    // 执行并进行错误处理
   bOk = func1();
   if(!bOk) goto errorhandle;

   bOk = func2();
   if(!bOk) goto errorhandle;

   bOk = func3();
   if(!bOk) goto errorhandle;

   // ..........

   // 执行成功，释放资源并返回
    free(p);   
    p = NULL;
    return true;

    errorhandle:
    free(p);   
    p = NULL;
    return false; 
}

代码冗余是解决了，但是引入了C语言中比较微妙的goto语句，虽然正确的使用goto语句可以大大提高程序的灵活性与简洁性，但是会使我们的程序捉摸不定，为了既避免使用goto语句，又能消除代码冗余，可以考虑使用下面的 do…while(0)：

#defien N 10
 
 bool Execute()
 {
     //分配资源
     int *p = (int *)malloc(N * sizeof(int));
     bool bOK = true;
 
 
    do {
        //执行并进行错误处理
        bOK = fun1();
        if(!bOK) break;

        bOK = fun2();
        if(!bOK) break;

        bOK = fun3();
        if(!bOK) break;

        //.........
    }  while(0);

    //释放资源
    
    free(p);
    p = NULL;
    return bOK;
}

3、避免空声明在编译时出现警告：

在linux内核源代码中，经常看到如下宏以避免在编译时出现警告：

#define FOO do { } while(0)

空语句在编译时候会出现警告，所以有必要用#define FOO do { } while(0).

4、提供一个声明局部变量的基础块：

你可能经常会使用如下的宏：

#define exch(x,y) { int tmp; tmp=x; x=y; y=tmp; }
然而在某些情况下将会失效，下面的代码使用if…else…

if (x > y)
        exch(x,y);          // 分支 1
else  
        do_something();     // 分支 2

但是将被解释为一个分支的if语句：

if (x > y) {     
        int tmp;            
        tmp = x;            
        x = y;
        y = tmp;
}
;                           // 空语句
else                        // ERROR!!! 
        do_something();

错误出在“;”直接位于代码块的后面，解决的办法是将代码嵌入do…while(0)，于是得到下面的代码：

if (x > y)
	do {
			int tmp;
            tmp = x;
			x = y;
	       y = tmp;
       } while(0);
else
	do_something();

于是上面的宏可以修改为：

#define exch(x,y) do {\
                int tmp;\
                tmp = x;\
                x = y;\
                y = tmp;\
        } while(0)

5、在条件语句中使用复杂的宏：

假如一个宏包含类似如下几行代码：

#define FOO(x) \
        printf("arg is %s\n", x); \
        do_something_useful(x);

现在想像一下下面的代码：

if (blah == 2)
        FOO(blah);

这将解释为：

if (blah == 2)
        printf("arg is %s\n", blah);
        do_something_useful(blah);;

我们就会发现，if语句只作用于printf(), do_something_useful() 没按照愿意一起执行，即没有像你预期的那样被包含在if代码中，于是可以使用如下的代码块：

if (blah == 2)
        do {
                printf("arg is %s\n", blah);
                do_something_useful(blah);
        } while (0);

这样上面的宏就可以改为：

#define  FOO(x) do { \
                printf("arg is %s\n", blah);\
                do_something_useful(blah);\
        } while (0)

以上的第四种和第五种技巧，并不是唯一的方法，有同学留言说用其他的方法也可以实现，反而显得这样的宏定义过于花哨？事实并非如此，这样的宏定义在linux内核代码中非常常见，原因是代码简洁、通用、可移植性好。