有什么更好的方法可以避免do-while（0）; 用C ++破解？

当代码流是这样的：

if(check())
{
  ...
  ...
  if(check())
  {
    ...
    ...
    if(check())
    {
      ...
      ...
    }
  }
}

我通常会看到此方法可以避免上述凌乱的代码流：

do {
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
} while(0);

有什么更好的方法来避免这种变通方法/黑客行为，从而使其成为更高级别（行业级别）的代码？

欢迎开箱即用的任何建议！

将这些决策隔离在一个函数中并使用returns代替breaks 被认为是可接受的做法。尽管所有这些检查都对应于与函数相同的抽象级别，但这是非常合乎逻辑的方法。

例如：

void foo(...)
{
   if (!condition)
   {
      return;
   }
   ...
   if (!other condition)
   {
      return;
   }
   ...
   if (!another condition)
   {
      return;
   }
   ... 
   if (!yet another condition)
   {
      return;
   }
   ...
   // Some unconditional stuff       
}

有时候，使用goto实际上是正确的答案-至少对于那些没有因宗教信仰而长大的人来说，“goto无论问题是什么，永远都不可能成为答案”-这就是其中一种情况。

此代码仅将hack do { ... } while(0);用作将a装扮goto成break。如果您要使用goto，请对此保持开放。使代码更难阅读没有意义。

一种特殊情况就是当您有很多代码且条件相当复杂时：

void func()
{
   setup of lots of stuff
   ...
   if (condition)
   {
      ... 
      ...
      if (!other condition)
      {
          ...
          if (another condition)
          {
              ... 
              if (yet another condition)
              {
                  ...
                  if (...)
                     ... 
              }
          }
      }
  .... 

  }
  finish up. 
}

实际上，由于没有如此复杂的逻辑，因此可以使代码更清楚。

void func()
{
   setup of lots of stuff
   ...
   if (!condition)
   {
      goto finish;
   }
   ... 
   ...
   if (other condition)
   {
      goto finish;
   }
   ...
   if (!another condition)
   {
      goto finish;
   }
   ... 
   if (!yet another condition)
   {
      goto finish;
   }
   ... 
   .... 
   if (...)
         ...    // No need to use goto here. 
 finish:
   finish up. 
}

编辑：澄清一下，我绝不是建议将其goto用作一般解决方案。但是在某些情况下goto有比其他解决方案更好的解决方案。

想象一下，例如，我们正在收集一些数据，而要测试的不同条件是某种“这就是收集的数据的结束”，这取决于某种“继续/结束”标记，这些标记随位置而异您在数据流中。

现在，完成后，我们需要将数据保存到文件中。

是的，通常还有其他解决方案可以提供合理的解决方案，但并非总是如此。

您可以将简单的延续模式与bool变量一起使用：

bool goOn;
if ((goOn = check0())) {
    ...
}
if (goOn && (goOn = check1())) {
    ...
}
if (goOn && (goOn = check2())) {
    ...
}
if (goOn && (goOn = check3())) {
    ...
}

checkN返回时，该执行链将停止false。check...()由于&&操作员的短路，不会再执行其他呼叫。此外，优化的编译器是足够聪明，认识到设置goOn到false是单行道，并插入缺少的goto end为您服务。结果，上面的代码的性能将与do/ 的性能相同while(0)，而不会对其可读性造成痛苦的打击。

1. 尝试将代码提取到一个单独的函数中（或多个）。如果检查失败，则从函数返回。

2. 如果它与周围的代码过于紧密地耦合而无法执行此操作，并且您找不到减少耦合的方法，请在此代码块之后查看代码。据推测，它清除了该函数使用的一些资源。尝试使用RAII对象管理这些资源；然后将每个狡猾的对象替换break为return（或throw，如果更合适的话），然后让对象的析构函数为您清除。

3. 如果程序流程过于混乱（以至于您确实需要）goto，请使用而不是给它一个奇怪的掩饰。

4. 如果您有盲目禁止的编码规则goto，并且您确实无法简化程序流程，那么您可能不得不用do黑客来掩饰它。

TLDR：RAII，事务代码（仅设置结果或在已经计算出结果时返回内容）和异常。

长答案：

在C语言中，此类代码的最佳实践是在代码中添加EXIT / CLEANUP / 其他标签，在该标签中会发生本地资源的清理并返回错误代码（如果有）。这是最佳实践，因为它自然地将代码分为初始化，计算，提交和返回：

error_code_type c_to_refactor(result_type *r)
{
    error_code_type result = error_ok; //error_code_type/error_ok defd. elsewhere
    some_resource r1, r2; // , ...;
    if(error_ok != (result = computation1(&r1))) // Allocates local resources
        goto cleanup;
    if(error_ok != (result = computation2(&r2))) // Allocates local resources
        goto cleanup;
    // ...

    // Commit code: all operations succeeded
    *r = computed_value_n;
cleanup:
    free_resource1(r1);
    free_resource2(r2);
    return result;
}

在C中，在大多数代码库中，if(error_ok != ...和goto代码通常隐藏在一些很方便的宏（RET(computation_result)，ENSURE_SUCCESS(computation_result, return_code)等）。

C ++比C提供了更多工具：

• 清除块功能可以实现为RAII，这意味着您不再需要整个cleanup块，并使客户端代码能够添​​加早期返回语句。

• 每当无法继续时，您都将抛出该异常，从而将所有这些if(error_ok != ...转换为直接调用。

等效的C ++代码：

result_type cpp_code()
{
    raii_resource1 r1 = computation1();
    raii_resource2 r2 = computation2();
    // ...
    return computed_value_n;
}

这是最佳做法，因为：

• 它是显式的（也就是说，虽然错误处理不是显式的，但是算法的主要流程是）

• 编写客户端代码很简单

• 最小

• 很简单

• 它没有重复的代码构造

• 它不使用宏

• 它不使用奇怪的do { ... } while(0)构造

• 它是可以重用的，只需花费很少的精力（也就是说，如果我想将调用复制computation2();到另一个函数，则不必确保do { ... } while(0)在新代码中添加，也不必确保添加#definegoto包装宏和清理标签，也不必还要别的吗）。

为了完整起见，我添加一个答案。许多其他答案指出，大条件块可以拆分为单独的函数。但是，正如多次指出的那样，这种方法将条件代码与原始上下文分开。这是lambda被添加到C ++ 11语言的原因之一。其他人建议使用lambda，但未提供明确的示例。我在这个答案中放了一个。让我印象深刻的是，它do { } while(0)在很多方面都与这种方法非常相似-也许这意味着它仍然是goto变相...。

earlier operations
...
[&]()->void {

    if (!check()) return;
    ...
    ...
    if (!check()) return;
    ...
    ...
    if (!check()) return;
    ...
    ...
}();
later operations

当然不是的答案，但答案（为完整起见）

代替 ：

do {
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
} while(0);

您可以这样写：

switch (0) {
case 0:
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
}

这仍然是变相的goto，但是至少它不再是循环。这意味着您将不必非常仔细地检查是否没有继续块中隐藏的内容。

构造也很简单，您可以希望编译器对其进行优化。

正如@jamesdlin所建议的那样，您甚至可以将其隐藏在像

#define BLOC switch(0) case 0:

并像这样使用

BLOC {
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
}

这是可能的，因为C语言语法期望在切换之后有一个语句，而不是放在方括号中的语句，并且您可以在该语句之前放置一个case标签。到目前为止，我还没有看到允许这样做的意义，但是在这种特殊情况下，将开关隐藏在漂亮的宏后面很方便。

我建议一种类似于Mats answer减去不必要的方法goto。仅将条件逻辑放入函数中。始终运行的任何代码都应在调用程序中调用该函数之前或之后：

void main()
{
    //do stuff always
    func();
    //do other stuff always
}

void func()
{
    if (!condition)
        return;
    ...
    if (!other condition)
        return;
    ...
    if (!another condition)
        return;
    ... 
    if (!yet another condition)
        return;
    ...
}

代码流本身已经是函数中经常发生的代码异味。如果没有直接解决方案（该函数是常规检查函数），请使用RAII，以便您可以返回而不是跳转到该函数的结尾部分，可能会更好。

如果您不需要在执行过程中引入局部变量，那么通常可以将其展平：

if (check()) {
  doStuff();
}  
if (stillOk()) {
  doMoreStuff();
}
if (amIStillReallyOk()) {
  doEvenMore();
}

// edit 
doThingsAtEndAndReportErrorStatus()

与dasblinkenlight的答案类似，但避免if了代码审阅者可能“修复”的内部分配：

bool goOn = check0();
if (goOn) {
    ...
    goOn = check1();
}
if (goOn) {
    ...
    goOn = check2();
}
if (goOn) {
    ...
}

...

当需要在下一步之前检查步骤的结果时，我使用此模式，这与所有检查都可以使用大if( check1() && check2()...类型模式预先完成的情况不同。

使用例外。您的代码看起来更加简洁（并且为处理程序执行流程中的错误而专门创建了异常）。为了清理资源（文件描述符，数据库连接等），请阅读文章为什么C ++不提供“最终”构造？。

#include <iostream>
#include <stdexcept>   // For exception, runtime_error, out_of_range

int main () {
    try {
        if (!condition)
            throw std::runtime_error("nope.");
        ...
        if (!other condition)
            throw std::runtime_error("nope again.");
        ...
        if (!another condition)
            throw std::runtime_error("told you.");
        ...
        if (!yet another condition)
            throw std::runtime_error("OK, just forget it...");
    }
    catch (std::runtime_error &e) {
        std::cout << e.what() << std::endl;
    }
    catch (...) {
        std::cout << "Caught an unknown exception\n";
    }
    return 0;
}

对我do{...}while(0)来说很好。如果您不想看到do{...}while(0)，则可以为其定义替代关键字。

例：

//--------SomeUtilities.hpp---------
#define BEGIN_TEST do{
#define END_TEST }while(0);

//--------SomeSourceFile.cpp--------
BEGIN_TEST
   if(!condition1) break;
   if(!condition2) break;
   if(!condition3) break;
   if(!condition4) break;
   if(!condition5) break;

   //processing code here

END_TEST

我认为编译器将删除不必要的while(0)条件do{...}while(0)二进制版本，并将中断转换为无条件跳转。您可以确定它是汇编语言版本。

使用goto还可以产生更清晰的代码，并且使用条件然后跳转逻辑很简单。您可以执行以下操作：

{
   if(!condition1) goto end_blahblah;
   if(!condition2) goto end_blahblah;
   if(!condition3) goto end_blahblah;
   if(!condition4) goto end_blahblah;
   if(!condition5) goto end_blahblah;

   //processing code here

 }end_blah_blah:;  //use appropriate label here to describe...
                   //  ...the whole code inside the block.

请注意，标签位于结束符之后}。这是可以避免的一个可能的问题，goto因为您没有看到标签，所以无意间在它们之间放置了代码。现在就像do{...}while(0)没有条件代码。

为了使此代码更清晰，更易理解，您可以执行以下操作：

//--------SomeUtilities.hpp---------
#define BEGIN_TEST {
#define END_TEST(_test_label_) }_test_label_:;
#define FAILED(_test_label_) goto _test_label_

//--------SomeSourceFile.cpp--------
BEGIN_TEST
   if(!condition1) FAILED(NormalizeData);
   if(!condition2) FAILED(NormalizeData);
   if(!condition3) FAILED(NormalizeData);
   if(!condition4) FAILED(NormalizeData);
   if(!condition5) FAILED(NormalizeData);

END_TEST(NormalizeData)

这样，您可以执行嵌套块并指定要退出/退出的位置。

//--------SomeUtilities.hpp---------
#define BEGIN_TEST {
#define END_TEST(_test_label_) }_test_label_:;
#define FAILED(_test_label_) goto _test_label_

//--------SomeSourceFile.cpp--------
BEGIN_TEST
   if(!condition1) FAILED(NormalizeData);
   if(!condition2) FAILED(NormalizeData);

   BEGIN_TEST
      if(!conditionAA) FAILED(DecryptBlah);
      if(!conditionBB) FAILED(NormalizeData);   //Jump out to the outmost block
      if(!conditionCC) FAILED(DecryptBlah);

      // --We can now decrypt and do other stuffs.

   END_TEST(DecryptBlah)

   if(!condition3) FAILED(NormalizeData);
   if(!condition4) FAILED(NormalizeData);

   // --other code here

   BEGIN_TEST
      if(!conditionA) FAILED(TrimSpaces);
      if(!conditionB) FAILED(TrimSpaces);
      if(!conditionC) FAILED(NormalizeData);   //Jump out to the outmost block
      if(!conditionD) FAILED(TrimSpaces);

      // --We can now trim completely or do other stuffs.

   END_TEST(TrimSpaces)

   // --Other code here...

   if(!condition5) FAILED(NormalizeData);

   //Ok, we got here. We can now process what we need to process.

END_TEST(NormalizeData)

Spaghetti代码不是的错goto，而是程序员的错。您仍然可以在不使用的情况下生成意大利面条代码goto。

从功能编程的角度来看，这是一个众所周知且已解决的问题-也许是单子。

为了回应我在下面收到的评论，我在这里编辑了我的介绍：您可以在各个地方找到有关实现C ++ monad的完整详细信息，这将使您实现Rotsor的建议。弄混monad会花费一些时间，因此我将在这里建议一种快速的“穷人” monad式机制，您只需要boost :: optional就可以了。

设置计算步骤如下：

boost::optional<EnabledContext> enabled(boost::optional<Context> context);
boost::optional<EnergisedContext> energised(boost::optional<EnabledContext> context);

boost::none如果给定的可选步骤为空，则每个计算步骤显然都可以执行类似return 的操作。因此，例如：

struct Context { std::string coordinates_filename; /* ... */ };

struct EnabledContext { int x; int y; int z; /* ... */ };

boost::optional<EnabledContext> enabled(boost::optional<Context> c) {
   if (!c) return boost::none; // this line becomes implicit if going the whole hog with monads
   if (!exists((*c).coordinates_filename)) return boost::none; // return none when any error is encountered.
   EnabledContext ec;
   std::ifstream file_in((*c).coordinates_filename.c_str());
   file_in >> ec.x >> ec.y >> ec.z;
   return boost::optional<EnabledContext>(ec); // All ok. Return non-empty value.
}

然后将它们链接在一起：

Context context("planet_surface.txt", ...); // Close over all needed bits and pieces

boost::optional<EnergisedContext> result(energised(enabled(context)));
if (result) { // A single level "if" statement
    // do work on *result
} else {
    // error
}

这样做的好处是，您可以为每个计算步骤编写明确定义的单元测试。调用也读起来像普通的英语（通常是函数样式的情况）。

如果您不关心不变性，那么每次使用shared_ptr或类似的方法提出一些变化时，返回相同的对象会更方便。

如何将if语句移到产生数字或枚举结果的额外函数中？

int ConditionCode (void) {
   if (condition1)
      return 1;
   if (condition2)
      return 2;
   ...
   return 0;
}


void MyFunc (void) {
   switch (ConditionCode ()) {
      case 1:
         ...
         break;

      case 2:
         ...
         break;

      ...

      default:
         ...
         break;
   }
}

像这样的东西

#define EVER ;;

for(EVER)
{
    if(!check()) break;
}

或使用例外

try
{
    for(;;)
        if(!check()) throw 1;
}
catch()
{
}

使用异常，您还可以传递数据。

我并不特别喜欢使用 break或return在这种情况下。考虑到通常情况下，当我们面对这种情况时，这通常是一个比较长的方法。

如果我们有多个出口点，则当我们想知道什么将导致执行某些逻辑时，可能会造成困难：通常，我们只是继续向上执行包含该逻辑块的代码块，而这些代码块的标准告诉我们情况：

例如，

if (conditionA) {
    ....
    if (conditionB) {
        ....
        if (conditionC) {
            myLogic();
        }
    }
}

通过查看封闭的块，很容易发现myLogic()只有在conditionA and conditionB and conditionCtrue 时才发生。

当有早期回报时，它变得不那么明显了：

if (conditionA) {
    ....
    if (!conditionB) {
        return;
    }
    if (!conditionD) {
        return;
    }
    if (conditionC) {
        myLogic();
    }
}

我们不能再从上浏览myLogic()，而是查看封闭的框来找出情况。

我使用了不同的解决方法。这是其中之一：

if (conditionA) {
    isA = true;
    ....
}

if (isA && conditionB) {
    isB = true;
    ...
}

if (isB && conditionC) {
    isC = true;
    myLogic();
}

（当然，欢迎使用相同的变量替换所有 isA isB isC。）

这种方法将至少为读者提供代码，该代码在以下myLogic()情况下执行isB && conditionC。提示读者他需要进一步查找将导致isB为真的内容。

typedef bool (*Checker)();

Checker * checkers[]={
 &checker0,&checker1,.....，&checkerN,NULL
};

bool checker1(){
  if(condition){
    .....
    .....
    return true;
  }
  return false;
}

bool checker2(){
  if(condition){
    .....
    .....
    return true;
  }
  return false;
}

......

void doCheck(){
  Checker ** checker = checkers;
  while( *checker && (*checker)())
    checker++;
}

那个怎么样？

如果需要根据失败的位置采取不同的清理步骤，则另一种模式很有用：

    private ResultCode DoEverything()
    {
        ResultCode processResult = ResultCode.FAILURE;
        if (DoStep1() != ResultCode.SUCCESSFUL)
        {
            Step1FailureCleanup();
        }
        else if (DoStep2() != ResultCode.SUCCESSFUL)
        {
            Step2FailureCleanup();
            processResult = ResultCode.SPECIFIC_FAILURE;
        }
        else if (DoStep3() != ResultCode.SUCCESSFUL)
        {
            Step3FailureCleanup();
        }
        ...
        else
        {
            processResult = ResultCode.SUCCESSFUL;
        }
        return processResult;
    }

我不是C ++程序员，所以在这里我不会写任何代码，但是到目前为止，没有人提到面向对象的解决方案。所以这是我的猜测：

具有通用接口，该接口提供一种评估单个条件的方法。现在，您可以在包含相关方法的对象中使用这些条件的实现列表。您遍历该列表并评估每种条件，如果一个条件失败，可能会提早爆发。

好的是，这样的设计很好地遵循了开/关原理，因为您可以在包含所讨论方法的对象初始化期间轻松添加新条件。您甚至可以在接口中添加第二种方法，其中条件评估方法将返回条件描述。这可以用于自文档系统。

但是，缺点是，由于使用了更多的对象并且遍历了列表，因此所涉及的开销稍微增加了。

这就是我这样做的方式。

void func() {
  if (!check()) return;
  ...
  ...

  if (!check()) return;
  ...
  ...

  if (!check()) return;
  ...
  ...
}

首先，通过一个简短的示例来说明为什么gotoC ++不是一个好的解决方案：

struct Bar {
    Bar();
};

extern bool check();

void foo()
{
    if (!check())
       goto out;

    Bar x;

    out:
}

尝试将其编译为目标文件，然后看看会发生什么。然后尝试等效的do+ break+while(0)。

放在一边。要点如下。

如果整个函数失败，这些小小的代码块通常需要某种清理。当您“展开”部分完成的计算时，这些清理通常希望以与块本身相反的顺序进行。

获得这些语义的一种选择是RAII ; 参见@utnapistim的答案。C ++保证自动析构函数以与构造函数相反的顺序运行，自然会提供“解散”。

但这需要很多RAII类。有时一个更简单的选择就是使用堆栈：

bool calc1()
{
    if (!check())
        return false;

    // ... Do stuff1 here ...

    if (!calc2()) {
        // ... Undo stuff1 here ...
        return false;
    }

    return true;
}

bool calc2()
{
    if (!check())
        return false;

    // ... Do stuff2 here ...

    if (!calc3()) {
        // ... Undo stuff2 here ...
        return false;
    }

    return true;
}

...等等。这很容易审核，因为它会将“撤消”代码放在“执行”代码旁边。简单的审核是好的。这也使控制流程非常清晰。对于C来说，这也是一个有用的模式。

它可能要求calc函数接受大量参数，但是如果您的类/结构具有良好的内聚性，通常这不是问题。（也就是说，属于同一个对象的东西生活在一个对象中，因此这些函数可以使用指向少量对象的指针或引用，但仍然可以做很多有用的工作。）

如果您的代码中有很长的if..else if..else语句块，则可以尝试借助Functors或重写整个块function pointers。不一定总是正确的解决方案，但通常是。

http://www.cprogramming.com/tutorial/functors-function-objects-in-c++.html

我对这里提出的不同答案感到惊讶。但是，最后，在我必须更改的代码（即删除此do-while(0)hack或其他内容）中，我做了一些不同于此处提到的任何答案的事情，我感到困惑，为什么没人想到这一点。这是我所做的：

初始代码：

do {

    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
} while(0);

finishingUpStuff.

现在：

finish(params)
{
  ...
  ...
}

if(!check()){
    finish(params);    
    return;
}
...
...
if(!check()){
    finish(params);    
    return;
}
...
...
if(!check()){
    finish(params);    
    return;
}
...
...

因此，这里所做的是将整理工作隔离在一个函数中，并且事情突然变得如此简单和干净！

我认为该解决方案值得一提，因此请在此处提供。

将其合并为一个if语句：

if(
    condition
    && other_condition
    && another_condition
    && yet_another_condition
    && ...
) {
        if (final_cond){
            //Do stuff
        } else {
            //Do other stuff
        }
}

这是在Java之类的语言中使用的模式，其中删除了goto关键字。

如果对所有错误使用相同的错误处理程序，并且每个步骤都返回一个布尔值，表示成功：

if(
    DoSomething() &&
    DoSomethingElse() &&
    DoAThirdThing() )
{
    // do good condition action
}
else
{
    // handle error
}

（类似于tyzoid的回答，但条件是动作，&&防止第一次失败后再发生其他动作。）

为什么没有标记方法回答了很久以来就使用过。

//you can use something like this (pseudocode)
long var = 0;
if(condition)  flag a bit in var
if(condition)  flag another bit in var
if(condition)  flag another bit in var
............
if(var == certain number) {
Do the required task
}