C/C++ 为什么要专门设计个Do…While?

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

[[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来解答:

  1. class Solution { 
  2. public
  3.     bool reorderedPowerOf2(int n) { 
  4.         auto check = [](int n) { 
  5.             return (n&(n-1)) == 0; 
  6.         }; 
  7.  
  8.         string s = to_string(n); 
  9.         int len = s.size(); 
  10.         sort(s.begin(), s.end()); 
  11.  
  12.         do { 
  13.             if (s[0] == '0') { 
  14.                 continue
  15.             } 
  16.             if (check(stoi(s))) { 
  17.                 return true
  18.             } 
  19.         } while (next_permutation(s.begin(), s.end())); 
  20.  
  21.         return false
  22.     } 
  23. }; 

本题,在我们将字符串sort()以后,变成了字典升序,然后每次通过调用next_permutation() 修改字符串s,变成其中字母的下一个排列。当不存在下一个排列的时候(字符串已经变成字典序逆序),返回false。

在一开始进来的时候不能。

  1. while (next_permutaion(s.begin(), s.end()) { 
  2.     if (s[0] == '0') { 
  3.         continue
  4.     } 
  5.     if (check(stoi(s))) { 
  6.         return true
  7.     } 

因为这样会导致sort完成的那个s(升序)没有参与到check的计算,造成遗漏。

如果不能do ... while就只能这样写:

  1. sort(s.begin(), s.end()); 
  2.  
  3.         if (s[0] != '0' && check(stoi(s))) { 
  4.             return true
  5.         } 
  6.         while (next_permutation(s.begin(), s.end())) { 
  7.             if (s[0] == '0') { 
  8.                 continue
  9.             } 
  10.             if (check(stoi(s))) { 
  11.                 return true
  12.             } 
  13.         } 

在while执行之前做一次check计算,然后才进入while。逻辑上当然没问题,只是造成了代码冗余。

当然这是do ... while最初的用法,后面程序员们集思广益,又利用do ... while的特性发明了独特了 do ... while(0)的特殊使用场景。

do ... while(0) 搭配宏函数的定义

C和C++语言中有宏的概念,而Java没有,所以这个条款对Java程序员没有用。

在C/C++中,有时候我们可能用宏来定义“函数”。我们都知道其本质还是宏,而非函数。所以其实还是在编译预处理阶段进行代码文本的暴力替换!而如果你定义的宏函数中的代码,被插入的位置,附近有括号或分号,有时候常常不能如你所愿的编译运行。

而do ... while(0)构造的代码块则不会受到大括号、分号等的影响。不管你把你的宏函数放到任何地方都不会出错。

比如Redis源码中就有大量的这种用法,下面这段出自zmalloc的源码:

  1. #define update_zmalloc_stat_alloc(__n) do { \ 
  2.     size_t _n = (__n); \ 
  3.     if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \ 
  4.     if (zmalloc_thread_safe) { \ 
  5.         update_zmalloc_stat_add(_n); \ 
  6.     } else { \ 
  7.         used_memory += _n; \ 
  8.     } \ 
  9. } while(0) 

do ... while(0) 中断顺序执行的逻辑

这个条款适用于C、C++、Java等有do ... while用法的语言。由于Java中int和bool不能转换,所以在Java中是:

  1. do { 
  2.  
  3. } 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)

  1. do { 
  2.     // 步骤1 
  3.     ... 
  4.     if (步骤1失败) { 
  5.         break; 
  6.     } 
  7.     // 步骤2 
  8.     ... 
  9.     if (步骤2失败) { 
  10.         break; 
  11.     } 
  12.     // 步骤3 
  13.     ... 
  14.     if (步骤3失败) { 
  15.         break; 
  16.     } 
  17. } while(0); 
  18.  
  19. // 步骤4 
  20. ... 
  21. // 步骤5 
  22. ... 

这个其实也适用于其他用do while的语言,不止C++。当然关于这个用法在C++11以后,很多人提出,用立即执行的lambda会更好,表现力会更强一些:

  1. [...](...) { // 通过捕获或传参传入一些上下文中的变量, 
  2.              // 用...替代,表示省略 ...不是语法的一部分! 
  3.     // 步骤1 
  4.     ... 
  5.     if (步骤1失败) { 
  6.         return
  7.     } 
  8.     // 步骤2 
  9.     ... 
  10.     if (步骤2失败) { 
  11.         return
  12.     } 
  13.     // 步骤3 
  14.     ... 
  15.     if (步骤3失败) { 
  16.         return
  17.     } 
  18. }(); // 比普通lambda表达式多了一个括号,表示立即执行 

这种匿名的、定义处立即执行的lambda,也叫IIFE(Immediately Invoked Function Expression) ,翻译成:立即调用函数表达式。IIFE是Javascript中的概念,见国外有些人也把C++的这种lambda表达式用法称作IIFE,私以为可能不是C++这边的官方说法。

Anyway,不过其实IIFE的风格,代码量上也并没有比do ... while(0)减少多少,而且还要额外的传参或捕获。支持者们认为,这里面的return中断逻辑,要比do ... while(0)的 break表达中断要好。这个……见仁见智吧。

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

 

 

责任编辑:武晓燕 来源: 编程往事
相关推荐

2024-02-26 12:13:32

C++开发编程

2022-11-28 09:58:58

C++开发

2010-01-20 14:03:12

C++程序

2010-01-22 15:14:37

学习C++

2022-01-17 21:08:54

Python 循环结构

2010-11-03 09:22:00

C语言

2021-12-03 17:22:09

CC++编程语言

2024-01-24 11:24:03

C++编程异常处理

2015-05-25 15:31:56

C语言学习和使用 C 语言

2014-04-24 13:43:37

CC++单元测试框架

2010-01-22 10:36:25

C++语言

2012-05-18 10:21:30

程序员CC++

2020-07-23 08:18:27

C语言执行循环体条件

2020-07-02 14:12:52

C++语言编程

2013-02-28 09:42:25

DIND 10C++Python

2022-07-21 09:15:28

C++垃圾回收

2016-12-01 11:20:42

2023-11-02 09:59:53

C++设计模式

2022-06-02 08:48:39

Go枚举器Iota

2010-01-26 13:36:27

C++设计
点赞
收藏

51CTO技术栈公众号