do.......while(0)

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

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

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

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

2.避免if  else  不匹配；
舉例說明如下：

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

#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)
        PRINT_STRING(isDoc);
    else
        doOtherThing();

則此代碼相當於

bool isReady = 
false;
    bool isDoc = true;
    if(isReady)
        if(isDoc)
            printDoc();
        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);，將你的代碼寫在裏面，裏面可以定義變量而不用考慮變量名會同函數之前或者之後的重複。