非常简单。

if ((bool conditionA = executeStepA()) && 
    (bool conditionB = executeStepB()) &&
    (bool conditionC = executeStepC())) {
   ...
}
executeThisFunctionInAnyCase();

这将保留布尔变量conditionA, conditionB和conditionC。

假设所需的代码是我目前看到的:

bool conditionA = executeStepA();
if (conditionA){
    bool conditionB = executeStepB();
    if (conditionB){
        bool conditionC = executeStepC();
        if (conditionC){
            ...
        }
    }
}    
executeThisFunctionInAnyCase();

我想说，正确的方法，因为它是最容易阅读和最容易维护的，应该有更少的缩进级别，这是(目前)这个问题的目的。

// Pre-declare the variables for the conditions
bool conditionA = false;
bool conditionB = false;
bool conditionC = false;

// Execute each step only if the pre-conditions are met
conditionA = executeStepA();
if (conditionA)
    conditionB = executeStepB();
if (conditionB)
    conditionC = executeStepC();
if (conditionC) {
    ...
}

// Unconditionally execute the 'cleanup' part.
executeThisFunctionInAnyCase();

这避免了对gotos、异常、dummy while循环或其他困难结构的任何需求，只需继续手头的简单工作。

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

[...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++中都是自动化的。

break语句可以以某种方式使用吗?

也许不是最好的解决办法，但你可以把你的陈述变成一种方式。While(0)循环并使用break语句而不是return。

到目前为止，有50多个答案，但没有人提到我在这种情况下通常会怎么做!(例如，一个由几个步骤组成的操作，但使用状态机或函数指针表将是多余的):

if ( !executeStepA() )
{
    // error handling for "A" failing
}
else if ( !executeStepB() )
{
    // error handling for "B" failing
}
else if ( !executeStepC() )
{
    // error handling for "C" failing
}
else
{
    // all steps succeeded!
}

executeThisFunctionInAnyCase();

优点:

最终不会有巨大的缩进水平 错误处理代码(可选)出现在失败函数调用之后的那几行中

缺点:

如果有一个步骤不是仅仅包含在一个函数调用中，会变得很糟糕吗 如果除了“按顺序执行步骤，如果一个失败就终止”之外，还需要任何流，那么就会变得很糟糕。

这样能行吗?我认为这与您的代码是等价的。

bool condition = true; // using only one boolean variable
if (condition) condition = executeStepA();
if (condition) condition = executeStepB();
if (condition) condition = executeStepC();
...
executeThisFunctionInAnyCase();