C语言中do...while(0)的妙用

在linux内核代码中，经常看到do...while(0)的宏，do...while(0)有很多作用，下面举出几个：

1、避免goto语句：

通常，如果一个函数开始要分配一些资源，然后如果在中途遇到错误则要退出函数，当然，退出前要释放资源，我们的代码可能如下：　

 1 #defien N 10

 2 

 3 bool Execute()

 4 {

 5    // 分配资源

 6    int *p = (int *)malloc(N * sizeof(int));

 7    bool bOk = true;

 8 

 9    // 执行并进行错误处理

10    bOk = func1();

11    if(!bOk) 

12    {

13       free(p);   

14       p = NULL;

15       return false;

16    }

17 

18    bOk = func2();

19    if(!bOk) 

20    {

21       free(p);   

22       p = NULL;

23       return false;

24    }

25 

26    bOk = func3();

27    if(!bOk) 

28    {

29       free(p);    

30       p = NULL;

31       return false;

32    }

33 

34    // ..........

35 

36    // 执行成功，释放资源并返回

37     free(p);   

38     p = NULL;

39     return true;

40 }

C代码

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

 1 #defien N 10

 2 

 3 bool Execute()

 4 {

 5    // 分配资源

 6    int *p = (int *)malloc(N * sizeof(int));

 7    bool bOk = true;

 8 

 9    // 执行并进行错误处理

10    bOk = func1();

11    if(!bOk) goto errorhandle;

12 

13    bOk = func2();

14    if(!bOk) goto errorhandle;

15 

16    bOk = func3();

17    if(!bOk) goto errorhandle;

18 

19    // ..........

20 

21    // 执行成功，释放资源并返回

22     free(p);   

23     p = NULL;

24     return true;

25 

26     errorhandle:

27     free(p);   

28     p = NULL;

29     return false; 

30 }

C代码

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

 1 #defien N 10

 2 

 3 bool Execute()

 4 {

 5     //分配资源

 6     int *p = (int *)malloc(N * sizeof(int));

 7     bool bOK = true;

 8 

 9 

10     do {

11         //执行并进行错误处理

12         bOK = fun1();

13         if(!bOK) break;

14 

15         bOK = fun2();

16         if(!bOK) break;

17 

18         bOK = fun3();

19         if(!bOK) break;

20 

21         //.........

22     }  while(0);

23 

24     //释放资源

25     

26     free(p);

27     p = NULL;

28     return bOK;

29 }

C代码

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

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

#define FOO do { } while(0)

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

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

#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)，于是得到下面的代码：

1 if (x > y)

2         do {

3                 int tmp;

4                 tmp = x;

5                 x = y;

6                 y = tmp;

7         } while(0);

8 else

9         do_something();

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

1 #define exch(x,y)       do {\

2                 int tmp;\

3                 tmp = x;\

4                 x = y;\

5                 y = tmp;\

6         } while(0)

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

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

#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);

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

1 #define  FOO(x) do { \

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

3                 do_something_useful(blah);\

4         } while (0)

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