只做

if( executeStepA() && executeStepB() && executeStepC() )
{
    // ...
}
executeThisFunctionInAnyCase();

就是这么简单。

由于三次编辑都从根本上改变了问题(如果算上版本1的修订，则是四次)，我包括了我正在回答的代码示例:

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

executeThisFunctionInAnyCase();

As @Jefffrey said, you can use the conditional short-circuit feature in almost every language, I personally dislike conditional statements with more than 2 condition (more than a single && or ||), just a matter of style. This code does the same (and probably would compile the same) and it looks a bit cleaner to me. You don't need curly braces, breaks, returns, functions, lambdas (only c++11), objects, etc. as long as every function in executeStepX() returns a value that can be cast to true if the next statement is to be executed or false otherwise.

if (executeStepA())
 if (executeStepB())
  if (executeStepC())
   //...
    if (executeStepN()); // <-- note the ';'

executeThisFunctionInAnyCase();

任何时候，任何函数返回false，都不会调用下一个函数。

我喜欢@Mayerz的答案，因为你可以在运行时改变要调用的函数(以及它们的顺序)。这有点像观察者模式，其中有一组订阅者(函数、对象等)，只要满足给定的任意条件，就会调用和执行这些订阅者。在许多情况下，这可能是一个过度杀戮，所以明智地使用它:)

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

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

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

一个简单的解决方案是使用一个条件布尔变量，同一个变量可以重复使用，以检查顺序执行的所有步骤的结果:

    bool cond = executeStepA();
    if(cond) cond = executeStepB();
    if(cond) cond = executeStepC();
    if(cond) cond = executeStepD();

    executeThisFunctionInAnyCase();

并不是说在此之前没有必要这样做:bool cond = true;．.． 然后后跟if(cond) cond = executeStepA();cond变量可以立即赋值给executeStepA()的结果，因此使代码更短，更易于阅读。

另一个更奇特但有趣的方法是这样的(有些人可能认为这是IOCCC的一个很好的候选，但仍然如此):

    !executeStepA() ? 0 :
      !executeStepB() ? 0 :
      !executeStepC() ? 0 :
      !executeStepD() ? 0 : 1 ;

    executeThisFunctionInAnyCase();

结果是完全相同的，如果我们做什么OP张贴，即:

    if(executeStepA()){
        if(executeStepB()){
            if(executeStepC()){
                if(executeStepD()){
                }
            }
        }
    }

    executeThisFunctionInAnyCase();

已经有很多不错的答案了，但大多数答案似乎都牺牲了一些(诚然，很少)灵活性。一种不需要这种权衡的常见方法是添加状态/持续变量。当然，价格是需要跟踪的额外价值:

bool ok = true;
bool conditionA = executeStepA();
// ... possibly edit conditionA, or just ok &= executeStepA();
ok &= conditionA;

if (ok) {
    bool conditionB = executeStepB();
    // ... possibly do more stuff
    ok &= conditionB;
}
if (ok) {
    bool conditionC = executeStepC();
    ok &= conditionC;
}
if (ok && additionalCondition) {
    // ...
}

executeThisFunctionInAnyCase();
// can now also:
return ok;

为什么使用OOP?在伪代码:

abstract class Abstraction():
   function executeStepA(){...};
   function executeStepB(){...};   
   function executeStepC(){...};
   function executeThisFunctionInAnyCase(){....}
   abstract function execute():

class A(Abstraction){
   function execute(){
      executeStepA();
      executeStepB();
      executeStepC();
   }
}
 class B(Abstraction){
   function execute(){
      executeStepA();
      executeStepB();
   }
}
class C(Abstraction){
     function execute(){
       executeStepA();
     }
}

这样你的如果就消失了

item.execute();
item.executeThisFunctionInAnyCase();

通常，使用OOP可以避免if。