你只用do-while來實現迴圈？太浪費了！

這是道哥的第010篇原創

目錄

• 前言
• 在巨集定義中的妙用
  • 錯誤的巨集定義
  • 比較好的巨集定義
  • 另一個也不錯的巨集定義
• 在函式體中的妙用
  • 函式功能：返回錯誤程式碼對應的錯誤字串
  • 函式功能：通過TCP Socket連線伺服器
  • 解決多個return的問題
  • 解決goto的問題
• 總結

前言

這篇文章講解的知識點很小，但是在一些程式設計場合中非常適用，大家可以把這篇短文當做甜品來品味一下。

地球人都知道，do-while語句是C/C++中的一個迴圈語句，特點是:

至少執行一次迴圈體;
在迴圈的尾部進行結束條件的判斷。

其實do-while還可以用在其他一些場合中，非常巧妙的處理你的一些難題，比如：

在巨集定義中寫複雜的語句;
在函式體中中止程式碼段的處理。

好像有點抽象，那我們就來具體一些，通過程式碼來聊聊這些用法。

也強烈建議您在平常的專案中把這些小技巧用起來，模仿是第一步，先僵化-再優化-最後固化，這是提高程式設計能力的最有效方法。
時間久了，用的多了，這些東西就是屬於你的。

在巨集定義中的妙用

錯誤的巨集定義

// 目的：把兩個引數分別自增一下
#define OPT(a, b)   a++; b++;

int main(int argc, char *argv[])
{
    int i = 1;
    int j = 1;
    OPT(i, j);
    printf("i = %d, j = %d \n", i, j);
    return 0;
}

測試一下，結果沒有問題(程式碼的目的就是讓i和j這個2個變數都自增1)：

i = 2, j = 2

而且OPT(i, j);中，最後的分號還可以省略，編譯和結果都沒有問題。

但是估計沒有誰會在專案中這麼使用巨集吧？！看一下下面這個例子：
在呼叫OPT巨集的外層新增一個if條件判斷：

#define OPT(a, b)   a++; b++;

int main(int argc, char *argv[])
{
    int i = 1;
    int j = 1;
    if(0)
        OPT(i, j);
    printf("i = %d, j = %d \n", i, j);
    return 0;
}

列印結果是：

i = 1, j = 2

問題出現了：我們的本意是if條件為假，這2個變數都不要自增，但是輸出結果卻是：第二個引數自增了。

其實問題很明顯，把巨集擴充套件開就一目瞭然了。

if(0)
    a++; b++;

錯誤原因一目瞭然：由於if語句沒有用大括號{}把需要執行的程式碼全部包裹住，導致只有a++;語句是在if語句的控制範圍，而b++;語句無論如何都被執行了。

也許你會說，這個簡單，使用if時，必須加上大括號{}。道理是沒錯，如果這個巨集定義只有你自己使用，這不成問題。但是如果巨集定義是你寫的，而使用者是你的同事，那麼你怎麼要求別人必須按照你所規定的格式來編碼？畢竟每個人的習慣是不一樣的。

很多時候，要求別人是不現實的。更有效的方法是優化自己的輸出，提供更安全的程式碼，讓別人想犯錯誤都沒機會。

比較好的巨集定義

怎麼做才能更安全？更通用呢？使用do-while！

#define OPT(a, b)   do{a++;b++;}while(0)

也就是說，只要巨集定義中存在多條語句，就可以用do-while把這些語句全部包裹起來，這樣無論怎麼使用這個巨集，都不會有問題。

例如：

if(0)
    OPT(i, j);

巨集擴充套件之後程式碼為：

if(0)
    do {
        a++;
        b++;
    }while(0);

如果給if加上大括號，視覺上會更好一些：

if(0) {
    OPT(i, j);
}

巨集擴充套件之後程式碼為：

if(0) {
    do {
        a++;
        b++;
    }while(0);
}

可以看到，無論是否加上大括號{}，從語法和語義上都不存在問題。

這裡還有一個小細節可以留意一下：OPT(i,j);這行程式碼中，尾部是加了分號的。

如果沒有加分號，那麼巨集擴充套件之後程式碼為：

if(0)
    do {
        a++;
        b++;
    }while(0) // 注意：這裡沒有分號

因為while(0)沒有分號，所以編譯會出錯。為了不對巨集的使用者提出要求，可以在巨集的最後加一個分號即可，如下：

#define OPT(a, b)   do{a++;b++;}while(0);

小結：使用do-while語句來包裹巨集定義中的多行語句，解決了巨集定義的安全問題。

但是，任何事情都不可能是完美的，例如：在巨集定義中使用do-while就無法返回一個結果。

也就是說：如果我們需要從巨集定義中返回一個結果，那麼do-while就派不上用場了。那應該怎麼辦？

另一個也不錯的巨集定義

如果巨集定義需要返回一個結果，最好的方式就是：使用({...})把巨集定義中的多行語句包裹起來。如下：

#define ADD(a, b, c) ({ ++a; ++b; c=a+b; })

int i = 1;
int j = 2;
int k;
printf("k = %d \n", ADD(i, j, k));

下面這張圖來自GNU官方文件：

翻譯過來就是：

GNU C中，在圓括號()中寫複雜語句是合法的，這樣你就可以在一個表示式中使用迴圈、switch、區域性變數了。
什麼是複雜語句呢？就是被大括號{}包裹的多行語句。
在上面的例項中，圓括號要放在大括號的外層。

使用({...})定義巨集，因為是多行語句，可以返回一個結果，比do-while更勝一籌。

這裡既然提到了在巨集定義中使用區域性變數，那我們再提供一個小技巧來提高程式碼的執行效率。

看一下這個巨集定義：

#define max(a,b) ({ (a) > (b) ? (a) : (b) })

float i = 1.234;
float j = 4.321;
float max = max((i / 0.8 + 5) / 3, (j * 0.8) / 1.5);

巨集擴充套件之後, a或者b中，肯定有一個被計算2次。當然，這裡的示例比較簡單，體現不出差距。如果是對時間要求特別苛刻的場合，計算量又很大，那麼這個巨集中由於兩次計算所耗費的時間就必須考慮了，那應該如何優化呢？使用區域性變數！

#define max(a,b)  ({ int _a = (a), _b = (b); _a > _b ? _a : _b; })

通過增加區域性變數_a和_b來快取計算結果，就消除了2次計算的問題。

這個例子還可以再繼續優化，這裡的區域性變數型別是int，這是寫死的，只能比較兩個整型的變數。如果寫成這樣：

#define max(a, b)  ({ typeof(a) _a = (a), _b = (b); _a > _b ? _a : _b; })

也就是用typeof來動態獲取比較變數的型別，這樣的話，任何數值型別的變數都可以使用這個巨集了。

關於typeof的說明，請看GNU的這張圖，在文末的參考連結中，可以看到更加詳細的官方說明。

在函式體中的妙用

先來看2段程式碼。

函式功能：返回錯誤程式碼對應的錯誤字串

char *get_error_msg(int err_code)
{
    if (1 == err_code) {
        return "invalid name";
    } else if (2 == err_code) {
        return "invalid password";
    } else if (3 == err_code) {
        return "network error";
    }
    
    return "unkown error";
}

思考：一個設計良好的函式只有一個出口，也就是return語句，但是這個函式有這麼多的return語句，是不是顯得很亂？示例程式碼體積很小，似乎沒有感覺。但是上百行的函式在專案中還是比較常見的，在這種情況下如果給你來個十幾個return語句，你會不會想把寫程式碼的那個傢伙拎過來扇幾巴掌？

函式功能：通過TCP Socket連線伺服器

void connect_server(char *ip, int port)
{
    int ret, sockfd;
    sockfd = socket(...);
    if (sockfd < 0) {
        printf("socket create failed! \n");
        goto end;
    }

    ret = connect(sockfd, ...);
    if (ret < 0) {
        printf("connect failed! \n");
        goto end;
    }

    ret = send(sockfd, ...)
    if (ret < 0) {
        printf("send failed! \n");
        goto end;
    }

end:
    其他程式碼
}

思考：TCP socket程式設計中，需要按照固定的順序呼叫多個系統函式。這段程式碼中呼叫系統函式後，對結果進行了檢查，這是非常好的習慣。如果在某個呼叫中發生錯誤，需要中止後面的操作，進行錯誤處理。雖然C語言中不禁止goto語句的使用，但是看到這麼多的goto，難道就沒有美觀、更優雅的做法嗎？

總結一下上面這2段程式碼，它們共同的特點是：

在一連串的語句中，只需要執行一部分的語句，也就是從程式碼塊的某個中間位置中止執行。

中止執行，我們首先想到的就是break關鍵字，它主要用在迴圈和switch語句中。do-while迴圈語句首先執行迴圈體，在尾部才進行迴圈的判斷。 那麼就可以利用這一點來解決這2段程式碼面對的問題。

解決多個return的問題

char *get_error_msg(int err_code)
{
    char *msg;
    do {
        if (1 == err_code) {
            msg = "invalid name";
            break;
        } else if (2 == err_code) {
            msg = "invalid password";
            break;
        } else if (3 == err_code) {
            msg = "network error";
            break;
        } else {
            msg = "unkown error";
            break;
        }
    }while(0);
    
    return msg;
}

解決goto的問題

void connect_server(char *ip, int port)
{
    int ret, sockfd;
    do {
        sockfd = socket(...);
        if (sockfd < 0) {
            printf("socket create failed! \n");
            break;
        }

        ret = connect(sockfd, ...);
        if (ret < 0) {
            printf("connect failed! \n");
            break;
        }

        ret = send(sockfd, ...)
        if (ret < 0) {
            printf("send failed! \n");
            break;
        }
    }while(0);

    其他程式碼
}

這樣的程式碼，是不是看起來順眼多了？

總結

do-while的主要作用是迴圈處理，但是在這篇文章中，我們利用的點並不是迴圈功能，而是程式碼塊的包裹和中止執行的功能。這些細小的點在一些牛逼的開原始碼中很常見，看到了我們就要學習、模仿、使用，用的多了它就是你的了！

是不是開始喜歡上do-while語句了？

參考文件：

[1] https://gcc.gnu.org/onlinedocs/gcc/Typeof.html
[2] https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html
[3] https://stackoverflow.com/questions/9495962/why-use-do-while-0-in-macro-definition
[4] https://gcc.gnu.org/onlinedocs/gcc-6.2.0/gcc/Statement-Exprs.html#Statement-Exprs

---

【原創宣告】
> 作者：道哥(公眾號: IOT物聯網小鎮)
> 知乎：道哥
> B站：道哥分享
> 掘金：道哥分享
> CSDN：道哥分享

如果覺得文章不錯，請轉發、分享給您的朋友。


我會把十多年嵌入式開發中的專案實戰經驗進行總結、分享，相信不會讓你失望的！

轉載：歡迎轉載，但未經作者同意，必須保留此段宣告，必須在文章中給出原文連線。 長按下圖二維碼關注，每篇文章都有乾貨。

---

<
推薦閱讀

[1] 原來gdb的底層除錯原理這麼簡單
[2] 生產者和消費者模式中的雙緩衝技術
[3] 深入LUA指令碼語言，讓你徹底明白除錯原理
[4] 一步步分析-如何用C實現物件導向程式設計