关于当前的代码示例，本质上是第二个问题，

[...block of code...]
bool conditionA = executeStepA();    
if (conditionA){
    [...block of code...]
    bool conditionB = executeStepB();
    if (conditionB){
        [...block of code...]
        bool conditionC = executeStepC();
        if (conditionC){
            ...other checks again...
        }
    }
}

executeThisFunctionInAnyCase();

除了将函数结果存储在变量中之外，这是典型的C代码。

如果布尔函数导致信号失败，那么c++的方法是使用异常，并将其编码为

struct Finals{ ~Finals() { executeThisFunctionInAnyCase(); } };

Finals finals;
// [...block of code...]
executeStepA();
// [...block of code...]
executeStepB();
// [...block of code...]
executeStepC();
//...other checks again...

然而，根据实际问题的不同，细节可能会有很大差异。

当我需要这样的通用最终操作时，我通常使用通用范围保护类，而不是当场定义一个自定义结构。作用域保护是由Petru Marginean为c++ 98发明的，然后使用临时生命周期扩展技巧。在c++ 11中，一般的范围保护类可以基于提供lambda表达式的客户端代码简单地实现。

在问题的最后，你建议了一个很好的C方法来做到这一点，即使用break语句:

for( ;; ) // As a block one can 'break' out of.
{
    // [...block of code...]
    if( !executeStepA() ) { break; }
    // [...block of code...]
    if( !executeStepB() ) { break; }
    // [...block of code...]
    if( !executeStepC() ) { break; }
    //...other checks again...
    break;
}
executeThisFunctionInAnyCase();

或者，对于C，将代码块中的代码重构为一个单独的函数，并使用return而不是break。因为它支持嵌套循环或开关，所以这更清楚也更通用。然而，你问的是休息。

与基于异常的c++方法相比，这种方法依赖于程序员记得检查每个函数的结果，并做正确的事情，这两者在c++中都是自动化的。

以下是我在C-whatever和Java中使用过的一个技巧:

do {
    if (!condition1) break;
    doSomething();
    if (!condition2) break;
    doSomethingElse()
    if (!condition3) break;
    doSomethingAgain();
    if (!condition4) break;
    doYetAnotherThing();
} while(FALSE);  // Or until(TRUE) or whatever your language likes

我更喜欢它而不是嵌套的if，因为它的清晰度，特别是当每个条件都有明确的注释时。

假设你不需要单独的条件变量，反转测试并使用else-falthrough作为“ok”路径，将允许你获得更垂直的if/else语句集:

bool failed = false;

// keep going if we don't fail
if (failed = !executeStepA())      {}
else if (failed = !executeStepB()) {}
else if (failed = !executeStepC()) {}
else if (failed = !executeStepD()) {}

runThisFunctionInAnyCase();

省略失败的变量使代码在我看来有点太晦涩了。

在里面声明变量就可以了，不用担心= vs ==。

// keep going if we don't fail
if (bool failA = !executeStepA())      {}
else if (bool failB = !executeStepB()) {}
else if (bool failC = !executeStepC()) {}
else if (bool failD = !executeStepD()) {}
else {
     // success !
}

runThisFunctionInAnyCase();

这很模糊，但很紧凑:

// keep going if we don't fail
if (!executeStepA())      {}
else if (!executeStepB()) {}
else if (!executeStepC()) {}
else if (!executeStepD()) {}
else { /* success */ }

runThisFunctionInAnyCase();

在某些特殊情况下，虚拟继承树和虚拟方法调用可以处理决策树逻辑。

objectp -> DoTheRightStep();

我遇到过这种情况，它就像魔杖一样有效。 当然，如果你的ConditionX可以始终如一地翻译成“object Is A”条件，这是有意义的。

关于当前的代码示例，本质上是第二个问题，

[...block of code...]
bool conditionA = executeStepA();    
if (conditionA){
    [...block of code...]
    bool conditionB = executeStepB();
    if (conditionB){
        [...block of code...]
        bool conditionC = executeStepC();
        if (conditionC){
            ...other checks again...
        }
    }
}

executeThisFunctionInAnyCase();

除了将函数结果存储在变量中之外，这是典型的C代码。

如果布尔函数导致信号失败，那么c++的方法是使用异常，并将其编码为

struct Finals{ ~Finals() { executeThisFunctionInAnyCase(); } };

Finals finals;
// [...block of code...]
executeStepA();
// [...block of code...]
executeStepB();
// [...block of code...]
executeStepC();
//...other checks again...

然而，根据实际问题的不同，细节可能会有很大差异。

当我需要这样的通用最终操作时，我通常使用通用范围保护类，而不是当场定义一个自定义结构。作用域保护是由Petru Marginean为c++ 98发明的，然后使用临时生命周期扩展技巧。在c++ 11中，一般的范围保护类可以基于提供lambda表达式的客户端代码简单地实现。

在问题的最后，你建议了一个很好的C方法来做到这一点，即使用break语句:

for( ;; ) // As a block one can 'break' out of.
{
    // [...block of code...]
    if( !executeStepA() ) { break; }
    // [...block of code...]
    if( !executeStepB() ) { break; }
    // [...block of code...]
    if( !executeStepC() ) { break; }
    //...other checks again...
    break;
}
executeThisFunctionInAnyCase();

或者，对于C，将代码块中的代码重构为一个单独的函数，并使用return而不是break。因为它支持嵌套循环或开关，所以这更清楚也更通用。然而，你问的是休息。

与基于异常的c++方法相比，这种方法依赖于程序员记得检查每个函数的结果，并做正确的事情，这两者在c++中都是自动化的。

把有条件的东西移到else中怎么样?

if (!(conditionA = executeStepA()){}
else if (!(conditionB = executeStepB()){}
else if (!(conditionC = executeStepC()){}
else if (!(conditionD = executeStepD()){}

这确实解决了缩进问题。