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

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

正如Rommik提到的，您可以为此应用设计模式，但我将使用Decorator模式而不是Strategy，因为您想要链式调用。如果代码很简单，那么我会选择一个结构良好的答案来防止嵌套。但是，如果它很复杂或者需要动态链接，那么Decorator模式是一个很好的选择。这是一个yUML类图:

下面是一个示例LinqPad c#程序:

void Main()
{
    IOperation step = new StepC();
    step = new StepB(step);
    step = new StepA(step);
    step.Next();
}

public interface IOperation 
{
    bool Next();
}

public class StepA : IOperation
{
    private IOperation _chain;
    public StepA(IOperation chain=null)
    {
        _chain = chain;
    }

    public bool Next() 
    {
        bool localResult = false;
        //do work
        //...
        // set localResult to success of this work
        // just for this example, hard coding to true
        localResult = true;
        Console.WriteLine("Step A success={0}", localResult);

        //then call next in chain and return
        return (localResult && _chain != null) 
            ? _chain.Next() 
            : true;
    }
}

public class StepB : IOperation
{
    private IOperation _chain;
    public StepB(IOperation chain=null)
    {
        _chain = chain;
    }

    public bool Next() 
    {   
        bool localResult = false;

        //do work
        //...
        // set localResult to success of this work
        // just for this example, hard coding to false, 
            // to show breaking out of the chain
        localResult = false;
        Console.WriteLine("Step B success={0}", localResult);

        //then call next in chain and return
        return (localResult && _chain != null) 
            ? _chain.Next() 
            : true;
    }
}

public class StepC : IOperation
{
    private IOperation _chain;
    public StepC(IOperation chain=null)
    {
        _chain = chain;
    }

    public bool Next() 
    {
        bool localResult = false;
        //do work
        //...
        // set localResult to success of this work
        // just for this example, hard coding to true
        localResult = true;
        Console.WriteLine("Step C success={0}", localResult);
        //then call next in chain and return
        return (localResult && _chain != null) 
            ? _chain.Next() 
            : true;
    }
}

恕我直言，关于设计模式最好的书是《Head First design patterns》。

代码中的IF/ELSE链不是语言的问题，而是程序设计的问题。如果你能够重构或重写你的程序，我建议你在Design Patterns (http://sourcemaking.com/design_patterns)中寻找更好的解决方案。

通常，当您在代码中看到大量IF & else时，就有机会实现策略设计模式(http://sourcemaking.com/design_patterns/strategy/c-sharp-dot-net)或其他模式的组合。

我确信有替代方案来编写一长串if/else，但我怀疑它们除了对你来说看起来很漂亮之外不会改变任何东西(然而，情人眼里出佳人仍然适用于代码:-))。你应该关心这样的事情(6个月后，当我有一个新的条件，我不记得关于这个代码的任何事情，我是否能够轻松地添加它?)或者如果链发生变化，我将如何快速和无错误地实现它)

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

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

另一种方法是do - while循环，尽管之前提到过，但没有例子可以显示它的样子:

do
{
    if (!executeStepA()) break;
    if (!executeStepB()) break;
    if (!executeStepC()) break;
    ...

    break; // skip the do-while condition :)
}
while (0);

executeThisFunctionInAnyCase();

(好吧，while循环已经有了一个答案，但do - while循环不会冗余检查true(在开始时)，而是在结束时检查xD(尽管可以跳过))。

非常简单。

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

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