内容摘要：最初do ... while的出现，更多的是作为循环控制流的一种语法糖。因为不论是while 还是 for循环，都是要先判断是否满足进入循环体的条件的。满足条件之后才能进入循环去执行循环体内的操作。而

最初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也介绍过了。

C++代码简化之道(一)

概括一下，函数(或方法)中一段顺序逻辑，依次经历1，2，3三个步骤，然后是其他逻辑(比如 4， 5)。其中1，如果失败就不执行2，2如果失败不执行3。就是逻辑中断之后直接跳到4和5。容易想到的实现思路有三：

把步骤1， 2，3抽象成函数。每次判断函数的返回值，成功才调用下一个函数。OK。这样没问题。但是如果这种类似的逻辑很多，就要抽成很多个函数，而每个函数内只有寥寥几行代码。未免啰嗦。 使用异常。如果是Java语言应该很习惯用异常来实现这个逻辑，把顺序逻辑封在try catch块里。每个步骤失败直接throw异常。OK，C++也可以写类似的代码。然而C++用异常隐患很多，不如Java安全，很多工程规范都竭力避免抛异常。另外就是抛异常也不是无开销的，而且这里只是逻辑中断，逻辑上也不算『异常』，通过throw异常和catch异常的方式未免影响代码可读性…… 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表达中断要好。这个……见仁见智吧。

本文转载自微信公众号「编程往事」，可以通过以下二维码关注。转载本文请联系编程往事公众号。