[[435891]]

最初do ... while的出現，更多的是作為循環控制流的一種語法糖。因為不論是while 還是 for循環，都是要先判斷是否滿足進入循環體的條件的。滿足條件之后才能進入循環去執行循環體內的操作。

而有些時候，第一次的執行邏輯我們不需要滿足循環條件，也要執行。這時候就可以用do ... while。舉個例子，前幾天的LeetCode每日一題 869. 重新排序得到2的冪，剛好遇到這么一個場景：

給定正整數 N ，我們按任何順序(包括原始順序)將數字重新排序，注意其前導數字不能為零。如果我們可以通過上述方式得到 2 的冪，返回 true;否則，返回 false。

• https://leetcode-cn.com/problems/reordered-power-of-2/

解題偷懶的話，可以直接用STL的排列相關的函數next_permutation來解答：

class Solution { 
public: 
    bool reorderedPowerOf2(int n) { 
        auto check = [](int n) { 
            return (n&(n-1)) == 0; 
        }; 
 
        string s = to_string(n); 
        int len = s.size(); 
        sort(s.begin(), s.end()); 
 
        do { 
            if (s[0] == '0') { 
                continue; 
            } 
            if (check(stoi(s))) { 
                return true; 
            } 
        } while (next_permutation(s.begin(), s.end())); 
 
        return false; 
    } 
}; 

本題，在我們將字符串sort()以后，變成了字典升序，然后每次通過調用next_permutation() 修改字符串s，變成其中字母的下一個排列。當不存在下一個排列的時候(字符串已經變成字典序逆序)，返回false。

在一開始進來的時候不能。

while (next_permutaion(s.begin(), s.end()) { 
    if (s[0] == '0') { 
        continue; 
    } 
    if (check(stoi(s))) { 
        return true; 
    } 
} 

因為這樣會導致sort完成的那個s(升序)沒有參與到check的計算，造成遺漏。

如果不能do ... while就只能這樣寫：

sort(s.begin(), s.end()); 
 
        if (s[0] != '0' && check(stoi(s))) { 
            return true; 
        } 
        while (next_permutation(s.begin(), s.end())) { 
            if (s[0] == '0') { 
                continue; 
            } 
            if (check(stoi(s))) { 
                return true; 
            } 
        } 

在while執行之前做一次check計算，然后才進入while。邏輯上當然沒問題，只是造成了代碼冗余。

當然這是do ... while最初的用法，后面程序員們集思廣益，又利用do ... while的特性發明了獨特了 do ... while(0)的特殊使用場景。

do ... while(0) 搭配宏函數的定義

C和C++語言中有宏的概念，而Java沒有，所以這個條款對Java程序員沒有用。

在C/C++中，有時候我們可能用宏來定義“函數”。我們都知道其本質還是宏，而非函數。所以其實還是在編譯預處理階段進行代碼文本的暴力替換!而如果你定義的宏函數中的代碼，被插入的位置，附近有括號或分號，有時候常常不能如你所愿的編譯運行。

而do ... while(0)構造的代碼塊則不會受到大括號、分號等的影響。不管你把你的宏函數放到任何地方都不會出錯。

比如Redis源碼中就有大量的這種用法，下面這段出自zmalloc的源碼：

#define update_zmalloc_stat_alloc(__n) do { \ 
    size_t _n = (__n); \ 
    if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \ 
    if (zmalloc_thread_safe) { \ 
        update_zmalloc_stat_add(_n); \ 
    } else { \ 
        used_memory += _n; \ 
    } \ 
} while(0) 

do ... while(0) 中斷順序執行的邏輯

這個條款適用于C、C++、Java等有do ... while用法的語言。由于Java中int和bool不能轉換，所以在Java中是：

do { 
 
} while (false); 

下面言歸正傳，關于這個用法，其實我在之前這篇文章的條款7也介紹過了。

[[435892]]

C++代碼簡化之道(一)

概括一下，函數(或方法)中一段順序邏輯，依次經歷1，2，3三個步驟，然后是其他邏輯(比如 4， 5)。其中1，如果失敗就不執行2，2如果失敗不執行3。就是邏輯中斷之后直接跳到4和5。容易想到的實現思路有三：

1. 把步驟1， 2，3抽象成函數。每次判斷函數的返回值，成功才調用下一個函數。OK。這樣沒問題。但是如果這種類似的邏輯很多，就要抽成很多個函數，而每個函數內只有寥寥幾行代碼。未免啰嗦。
2. 使用異常。如果是Java語言應該很習慣用異常來實現這個邏輯，把順序邏輯封在try catch塊里。每個步驟失敗直接throw異常。OK，C++也可以寫類似的代碼。然而C++用異常隱患很多，不如Java安全，很多工程規范都竭力避免拋異常。另外就是拋異常也不是無開銷的，而且這里只是邏輯中斷，邏輯上也不算『異常』，通過throw異常和catch異常的方式未免影響代碼可讀性……
3. goto【Java沒有，C和C++有】確實看過一些代碼確實在這種場合使用過goto。當然我們要嚴厲禁止goto。這個方案直接略過。

其實還有第4種方案：do while(0)

do { 
    // 步驟1 
    ... 
    if (步驟1失敗) { 
        break; 
    } 
    // 步驟2 
    ... 
    if (步驟2失敗) { 
        break; 
    } 
    // 步驟3 
    ... 
    if (步驟3失敗) { 
        break; 
    } 
} while(0); 
 
// 步驟4 
... 
// 步驟5 
... 

這個其實也適用于其他用do while的語言，不止C++。當然關于這個用法在C++11以后，很多人提出，用立即執行的lambda會更好，表現力會更強一些：

[...](...) { // 通過捕獲或傳參傳入一些上下文中的變量， 
             // 用...替代，表示省略 ...不是語法的一部分！ 
    // 步驟1 
    ... 
    if (步驟1失敗) { 
        return; 
    } 
    // 步驟2 
    ... 
    if (步驟2失敗) { 
        return; 
    } 
    // 步驟3 
    ... 
    if (步驟3失敗) { 
        return; 
    } 
}(); // 比普通lambda表達式多了一個括號，表示立即執行 

這種匿名的、定義處立即執行的lambda，也叫IIFE(Immediately Invoked Function Expression) ，翻譯成：立即調用函數表達式。IIFE是Javascript中的概念，見國外有些人也把C++的這種lambda表達式用法稱作IIFE，私以為可能不是C++這邊的官方說法。

Anyway，不過其實IIFE的風格，代碼量上也并沒有比do ... while(0)減少多少，而且還要額外的傳參或捕獲。支持者們認為，這里面的return中斷邏輯，要比do ... while(0)的 break表達中斷要好。這個……見仁見智吧。

本文轉載自微信公眾號「編程往事」，可以通過以下二維碼關注。轉載本文請聯系編程往事公眾號。