是否需要“做{…} while（）”循环？

Bjarne Stroustrup（C ++创建者）曾经说过，他避免执行“ do / while”循环，而是更喜欢使用“ while”循环来编写代码。[请参阅下面的引用。]

自从听到这句话以来，我发现这是真的。你怎么认为？有没有一个示例，其中“ do / while”比使用“ while”更清晰，更容易理解？

针对某些答案：是的，我了解“ do / while”和“ while”之间的技术区别。这是一个涉及循环的可读性和结构化代码的更深层问题。

让我问另一种方式：假设您被禁止使用“ do / while”-是否有一个现实的示例，除了使用“ while”编写不干净的代码，别无选择？

来自“ C ++编程语言”，6.3.3：

以我的经验，做陈述是错误和混乱的根源。原因是在评估条件之前，它的主体总是执行一次。但是，为了使身体正常工作，即使是第一次也必须保持这种状态。比起我想像的更多，我发现该条件在首次编写和测试程序时，或者在修改其之前的代码之后，均未达到预期。 我也更喜欢“可以看到它的前面”条件。因此，我倾向于避免执行陈述。-比耶恩

是的，我同意do while循环可以重写为while循环，但是我不同意始终使用while循环会更好。同时总是至少运行一次，这是一个非常有用的属性（最典型的示例是输入检查（通过键盘））

#include <stdio.h>

int main() {
    char c;

    do {
        printf("enter a number");
        scanf("%c", &c);

    } while (c < '0' ||  c > '9'); 
}

当然，可以将其重写为while循环，但这通常被认为是一种更为优雅的解决方案。

do-while是具有后置条件的循环。如果循环主体至少要执行一次，则需要使用它。这对于代码需要一些动作才能明智地评估循环条件是必要的。如果使用while循环，则必须从两个站点调用初始化代码，而使用do-while则只能从一个站点调用初始化代码。

另一个示例是，当要开始第一次迭代时您已经有一个有效的对象，因此您不想在第一次迭代开始之前执行任何操作（包括循环条件评估）。一个带有Win32函数的FindFirstFile / FindNextFile的示例：调用FindFirstFile，它向第一个文件返回错误或搜索句柄，然后调用FindNextFile，直到返回错误。

伪代码：

Handle handle;
Params params;
if( ( handle = FindFirstFile( params ) ) != Error ) {
   do {
      process( params ); //process found file
   } while( ( handle = FindNextFile( params ) ) != Error ) );
}

do { ... } while (0) 是使宏表现良好的重要构造。

即使在实际代码中不重要（我不一定同意），对于修复预处理程序的某些缺陷也很重要。

编辑：我遇到了这样的情况：在我自己的代码中，今天做/做得更干净。我正在对成对的LL / SC指令进行跨平台抽象。这些需要循环使用，如下所示：

do
{
  oldvalue = LL (address);
  newvalue = oldvalue + 1;
} while (!SC (address, newvalue, oldvalue));

（专家可能会意识到，在SC实现中未使用oldvalue，但已将oldvalue包括在内，以便可以用CAS模拟此抽象。）

LL和SC是以下情况的一个很好的例子：do / while比while形式等效得多：

oldvalue = LL (address);
newvalue = oldvalue + 1;
while (!SC (address, newvalue, oldvalue))
{
  oldvalue = LL (address);
  newvalue = oldvalue + 1;
}

因此，对于Google Go选择删除do-while构造的事实，我感到非常失望。

当您想要“做”某事直到满足条件时，它很有用。

可以在while循环中进行这样的操作：

while(true)
{

    // .... code .....

    if(condition_satisfied) 
        break;
}

（假设您知道两者之间的区别）

在检查条件并运行while循环之前，Do / While有助于引导/预初始化代码。

在我们的编码约定中

• 如果/ while / ...条件没有副作用，并且
• 变量必须初始化。

因此，我们几乎从来没有do {} while(xx) 因为：

int main() {
    char c;

    do {
        printf("enter a number");
        scanf("%c", &c);

    } while (c < '0' ||  c > '9'); 
}

改写为：

int main() {
    char c(0);
    while (c < '0' ||  c > '9');  {
        printf("enter a number");
        scanf("%c", &c);
    } 
}

和

Handle handle;
Params params;
if( ( handle = FindFirstFile( params ) ) != Error ) {
   do {
      process( params ); //process found file
   } while( ( handle = FindNextFile( params ) ) != Error ) );
}

改写为：

Params params(xxx);
Handle handle = FindFirstFile( params );
while( handle!=Error ) {
    process( params ); //process found file
    handle = FindNextFile( params );
}

以下常见用语对我来说似乎很简单：

do {
    preliminary_work();
    value = get_value();
} while (not_valid(value));

要避免的重写do似乎是：

value = make_invalid_value();
while (not_valid(value)) {
    preliminary_work();
    value = get_value();
}

第一行用于确保测试始终在第一时间评估为true。换句话说，第一次测试总是多余的。如果不存在此多余的测试，则也可以省略初始任务。这段代码给人的印象是它自己在战斗。

在这种情况下，do构造是非常有用的选择。

一切都与可读性有关。
更具可读性的代码减少了代码维护的麻烦，并改善了协作。
到目前为止，在大多数情况下，其他考虑因素（例如优化）的重要性不那么重要。
我会细说了，因为我有一个在这里评论：
如果你有一个代码段一使用do { ... } while()，而且它比其更具可读性while() {...}相当于乙，那么我会投票给一个。如果你喜欢乙，因为你看到的循环条件“前面”，你认为这是更具可读性（因此维护等） -那么请便，用乙。
我的观点是：使用对您（以及您的同事）而言更易读的代码。当然，选择是主观的。

这是我所见过的最干净的替代方法。这是不带do-while循环的Python建议使用的习惯用法。

一个警告是您不能使用continue，<setup code>因为它会跳过中断条件，但是没有任何一个显示do-while好处的示例在此条件之前需要继续。

while (true) {
       <setup code>
       if (!condition) break;
       <loop body>
}

在这里，它适用于上述do-while循环的一些最佳示例。

while (true);  {
    printf("enter a number");
    scanf("%c", &c);
    if (!(c < '0' ||  c > '9')) break;
} 

下一个示例是一种结构，其用法比做起来更易读的情况，因为条件通常保持在顶部附近，//get data通常较短，但该//process data部分可能很长。

while (true);  {
    // get data 
    if (data == null) break;
    // process data
    // process it some more
    // have a lot of cases etc.
    // wow, we're almost done.
    // oops, just one more thing.
} 

我认为这只是个人选择。

大多数时候，您可以找到一种将do ... while循环重写为while循环的方法；但不一定总是如此。同样，有时编写do while循环以适合您所处的上下文可能更合乎逻辑。

如果您从上方看，TimW的答复就说明了一切。我认为第二个带有Handle的控件尤其混乱。

阅读结构化程序定理。do {} while（）始终可以重写为while（）do {}。序列，选择和迭代都是所需要的。

由于循环主体中包含的所有内容始终可以封装到例程中，因此不必使用while（）do {}

LoopBody()
while(cond) {
    LoopBody()
}

我几乎不会仅仅因为以下原因而使用它们：

即使循环检查后置条件，您仍然需要在循环中检查该后置条件，以便您不处理后置条件。

采取示例伪代码：

do {
   // get data 
   // process data
} while (data != null);

从理论上讲听起来很简单，但在现实世界中，结果可能看起来像这样：

do {
   // get data 
   if (data != null) {
       // process data
   }
} while (data != null);

额外的“如果”检查就不值得IMO了。我发现很少有实例比执行while循环更简洁。YMMV。

为了回应未知（google）对Dan Olson的回答的问题/评论：

“做{...}，而（0）是使宏表现良好的重要构造。”

#define M do { doOneThing(); doAnother(); } while (0)
...
if (query) M;
...

您看到没有时会发生什么do { ... } while(0)吗？它将始终执行doAnother（）。

do-while循环始终可以重写为while循环。

是仅使用while循环，还是使用while，do-while和for循环（或其任意组合）在很大程度上取决于您的审美观和所从事项目的惯例。

就个人而言，我更喜欢while循环，因为它简化了关于循环不变式恕我直言的推理。

关于是否确实需要执行do-while循环：

do
{
  loopBody();
} while (condition());

你可以永远

loopBody();
while(condition())
{
  loopBody();
}

因此，不，如果由于某种原因不能使用do-while。（当然，此示例违反了DRY，但这只是概念证明。根据我的经验，通常有一种将do-while循环转换为while循环的方式，并且在任何具体用例中都不会违反DRY。）

“在罗马时，像罗马人一样做。”

顺便说一句：您正在寻找的报价可能就是这个（[1]，第6.3.3节的最后一段）：

根据我的经验，做陈述是错误和混乱的根源。原因是其主体始终在条件测试之前执行一次。但是，为了使身体正常工作，必须在初次运行中保持与最终状态相似的状态。比我预期的更多，我发现这些条件不成立。当我从头开始编写有问题的程序然后进行测试以及更改代码后，都是这种情况。另外，我更喜欢“在前面可以看到它的条件”。因此，我倾向于避免执行陈述。

（注意：这是我翻译的德语版。如果您是英文版的所有者，请随时对其报价进行修改，以使其与原文一致。不幸的是，Addison-Wesley讨厌Google。）

[1] B. Stroustrup： C ++编程语言。第三版。Addison-Wessley，《雷丁》，1997年。

首先，我同意它do-while的可读性不如while。

但是令我惊讶的是，经过如此多的回答，没有人考虑过为什么do-while甚至存在于该语言中。原因是效率。

可以说我们有一个do-while带有N条件检查的循环，其中条件的结果取决于循环主体。然后，如果将其替换为while循环，则会获得N+1条件检查，而多余的检查毫无意义。如果循环条件仅包含一个整数值的检查，那没什么大不了的，但是可以说我们有

something_t* x = NULL;

while( very_slowly_check_if_something_is_done(x) )
{
  set_something(x);
}

然后，循环的第一圈中的函数调用是多余的：我们已经知道它x尚未设置为任何东西。那么为什么要执行一些毫无意义的开销代码呢？

在对实时嵌入式系统进行编码时，我经常使用do-while来实现此目的，在该系统中，条件内的代码相对较慢（检查某些较慢的硬件外围设备的响应）。

考虑这样的事情：

int SumOfString(char* s)
{
    int res = 0;
    do
    {
        res += *s;
        ++s;
    } while (*s != '\0');
}

碰巧'\ 0'为0，但我希望您明白这一点。

我的do / while问题完全是在C中实现的。由于while关键字的重用，它经常使人绊倒，因为它看起来像是一个错误。

如果while仅保留了while循环，而do / while已更改为do /直到或重复/直到，则我认为循环（这当然很方便，并且是编写某些循环的“正确”方法）不会导致这么麻烦

关于JavaScript，我以前对此大加赞赏，它也从C继承了这个遗憾的选择。

好吧，这可能要退后几步，但是在

do
{
     output("enter a number");
     int x = getInput();

     //do stuff with input
}while(x != 0);

可能，尽管不一定可读

int x;
while(x = getInput())
{
    //do stuff with input
}

现在，如果您想使用非0的数字退出循环

while((x = getInput()) != 4)
{
    //do stuff with input
}

但是同样，可读性下降，更不用说在条件内使用赋值语句被认为是不好的做法，我只是想指出，执行赋值语句比分配“保留”值来指示要紧凑得多循环到它是最初运行的过程。

我喜欢DavidBožjak的榜样。但是，作为恶魔的拥护者，我觉得您总是可以将要至少运行一次的代码分解成一个单独的函数，从而实现最易读的解决方案。例如：

int main() {
    char c;

    do {
        printf("enter a number");
        scanf("%c", &c);

    } while (c < '0' ||  c > '9'); 
}

可能会变成这样：

int main() {
    char c = askForCharacter();
    while (c < '0' ||  c > '9') {
        c = askForCharacter();
    }
}

char askForCharacter() {
    char c;
    printf("enter a number");
    scanf("%c", &c);
    return c;
}

（原谅任何不正确的语法；我不是C程序员）