私がこの疑似コードを持っていると仮定します：

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

executeThisFunctionInAnyCase();

前の関数executeStepXが成功した場合にのみ、関数を実行する必要があります。いずれの場合も、executeThisFunctionInAnyCase関数は最後に呼び出す必要があります。私はプログラミングの初心者なので、非常に基本的な質問で申し訳ありません。ifコードの読みやすさを犠牲にして、そのような「コードのピラミッド」を生成する長いチェーンを回避する方法はありますか（C / C ++など）？

executeThisFunctionInAnyCase関数呼び出しをスキップできれば、コードは次のように簡略化できます。

bool conditionA = executeStepA();
if (!conditionA) return;
bool conditionB = executeStepB();
if (!conditionB) return;
bool conditionC = executeStepC();
if (!conditionC) return;

ただし、制約はexecuteThisFunctionInAnyCase関数呼び出しです。breakステートメントは何らかの方法で使用できますか？

&&（論理AND）を使用できます。

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

これにより、両方の要件が満たされます。

• executeStep<X>()前のテストが成功した場合にのみ評価する必要があります（これは短絡評価と呼ばれます）
• executeThisFunctionInAnyCase() いずれにしても実行されます

追加の関数を使用して、2番目のバージョンを機能させるだけです。

void foo()
{
  bool conditionA = executeStepA();
  if (!conditionA) return;

  bool conditionB = executeStepB();
  if (!conditionB) return;

  bool conditionC = executeStepC();
  if (!conditionC) return;
}

void bar()
{
  foo();
  executeThisFunctionInAnyCase();
}

深くネストされたifs（最初のバリアント）を使用するか、「関数の一部」から抜け出したいという願望は、通常、追加の関数が必要であることを意味します。

gotoこの場合、旧式のCプログラマーが使用します。これは、gotoLinuxスタイルガイドで実際に推奨されている使用法の1つであり、集中関数出口と呼ばれます。

int foo() {
    int result = /*some error code*/;
    if(!executeStepA()) goto cleanup;
    if(!executeStepB()) goto cleanup;
    if(!executeStepC()) goto cleanup;

    result = 0;
cleanup:
    executeThisFunctionInAnyCase();
    return result;
}

一部の人々gotoは、ボディをループに包み、そこから抜け出すことによって使用を回避しますが、効果的に両方のアプローチが同じことを行います。成功したgoto場合executeStepA()にのみ他のクリーンアップが必要な場合は、このアプローチの方が適しています。

int foo() {
    int result = /*some error code*/;
    if(!executeStepA()) goto cleanupPart;
    if(!executeStepB()) goto cleanup;
    if(!executeStepC()) goto cleanup;

    result = 0;
cleanup:
    innerCleanup();
cleanupPart:
    executeThisFunctionInAnyCase();
    return result;
}

ループアプローチでは、その場合、2つのレベルのループが発生します。

これは一般的な状況であり、それに対処する多くの一般的な方法があります。これが正解の私の試みです。何か見逃した場合はコメントしてください。この投稿は最新の状態に保ちます。

これは矢です

あなたが話していることは、矢印アンチパターンとして知られています。ネストされたifsのチェーンがコードブロックを形成し、コードペインが右側に「ポイント」する視覚的な矢印を形成するように、矢印ブロックと呼ばれます。

ガードで矢を平らにする

Arrowを回避するいくつかの一般的な方法をここで説明します。最も一般的な方法は、ガードパターンを使用することです。この場合、コードは最初に例外フローを処理し、次に基本フローを処理します。

if (ok)
{
    DoSomething();
}
else
{
    _log.Error("oops");
    return;
}

...使用します...

if (!ok)
{
    _log.Error("oops");
    return;
} 
DoSomething(); //notice how this is already farther to the left than the example above

一連のガードが長い場合、すべてのガードが左端まで表示され、ifがネストされていないため、コードがかなり平坦化されます。さらに、論理条件とそれに関連するエラーを視覚的に組み合わせているため、何が起こっているのかをはるかに簡単に判断できます。

矢印：

ok = DoSomething1();
if (ok)
{
    ok = DoSomething2();
    if (ok)
    {
        ok = DoSomething3();
        if (!ok)
        {
            _log.Error("oops");  //Tip of the Arrow
            return;
        }
    }
    else
    {
       _log.Error("oops");
       return;
    }
}
else
{
    _log.Error("oops");
    return;
}

ガード：

ok = DoSomething1();
if (!ok)
{
    _log.Error("oops");
    return;
} 
ok = DoSomething2();
if (!ok)
{
    _log.Error("oops");
    return;
} 
ok = DoSomething3();
if (!ok)
{
    _log.Error("oops");
    return;
} 
ok = DoSomething4();
if (!ok)
{
    _log.Error("oops");
    return;
} 

これは、客観的かつ定量的に読みやすいからです。

1. 特定の論理ブロックの{および}文字は、互いに接近しています
2. 特定の行を理解するために必要なメンタルコンテキストの量が少ない
3. if条件に関連するロジック全体が1ページにある可能性が高い
4. コーダーがページ/アイトラックをスクロールする必要性が大幅に軽減されます

最後に一般的なコードを追加する方法

ガードパターンの問題は、いわゆる「日和見的リターン」または「日和見的出口」に依存していることです。言い換えれば、すべての関数が厳密に1つの出口点を持つべきであるというパターンを破ります。これは2つの理由で問題です。

1. たとえば、Pascalでのコーディングを学んだ人は、1つの関数= 1つの出口点であることを知っています。
2. 対象となる内容に関係なく、終了時に実行されるコードのセクションは提供されません。

以下に、言語機能を使用するか、問題を完全に回避することにより、この制限を回避するためのいくつかのオプションを示します。

オプション1.これを行うことはできません。 finally

残念ながら、C ++開発者はこれを行うことはできません。しかし、これがまさにそれが目的であるので、これはfinallyキーワードを含む言語の一番の答えです。

try
{
    if (!ok)
    {
        _log.Error("oops");
        return;
    } 
    DoSomething(); //notice how this is already farther to the left than the example above
}
finally
{
    DoSomethingNoMatterWhat();
}

オプション2.問題を回避する：関数を再構成する

コードを2つの関数に分割することで問題を回避できます。このソリューションには、あらゆる言語で機能するという利点があり、さらに、サイクロマティックな複雑さを軽減できます。これは、欠陥率を低減する実証済みの方法であり、自動ユニットテストの特異性を向上させます。

次に例を示します。

void OuterFunction()
{
    DoSomethingIfPossible();
    DoSomethingNoMatterWhat();
}

void DoSomethingIfPossible()
{
    if (!ok)
    {
        _log.Error("Oops");
        return;
    }
    DoSomething();
}

オプション3.言語トリック：偽のループを使用する

他の答えに示されているように、私が目にするもう1つの一般的なトリックは、while（true）とbreakを使用することです。

while(true)
{
     if (!ok) break;
     DoSomething();
     break;  //important
}
DoSomethingNoMatterWhat();

これはを使用する場合よりも「正直」gotoではありませんが、ロジックスコープの境界を明確に示すため、リファクタリング時に混乱する可能性が低くなります。あなたのラベルまたはあなたのカットアンドペーストする素朴なコーダーgotoステートメントは、大きな問題を引き起こす可能性があります。（そして率直に言って、このパターンは非常に一般的であるようになりました。私はそれが意図を明確に伝えていると思うので、まったく「不誠実」ではありません）。

このオプションには他にもバリエーションがあります。たとえば、のswitch代わりにを使用できますwhile。breakキーワード付きの言語構成はおそらく機能するでしょう。

オプション4.オブジェクトのライフサイクルを活用する

他の1つのアプローチは、オブジェクトのライフサイクルを活用します。コンテキストオブジェクトを使用してパラメーター（私たちの素朴な例には疑わしいほど欠けているもの）を持ち歩き、完了したらそれを破棄します。

class MyContext
{
   ~MyContext()
   {
        DoSomethingNoMatterWhat();
   }
}

void MainMethod()
{
    MyContext myContext;
    ok = DoSomething(myContext);
    if (!ok)
    {
        _log.Error("Oops");
        return;
    }
    ok = DoSomethingElse(myContext);
    if (!ok)
    {
        _log.Error("Oops");
        return;
    }
    ok = DoSomethingMore(myContext);
    if (!ok)
    {
        _log.Error("Oops");
    }

    //DoSomethingNoMatterWhat will be called when myContext goes out of scope
}

注：選択した言語のオブジェクトのライフサイクルを必ず理解してください。これが機能するには、ある種の確定的なガベージコレクションが必要です。つまり、デストラクタがいつ呼び出されるかを知る必要があります。一部の言語では使用する必要がありますDisposeでは、デストラクタの代わり。

オプション4.1。オブジェクトのライフサイクルを活用する（ラッパーパターン）

オブジェクト指向のアプローチを使用する場合は、正しく実行することもできます。このオプションは、クラスを使用して、クリーンアップが必要なリソースとその他の操作を「ラップ」します。

class MyWrapper 
{
   bool DoSomething() {...};
   bool DoSomethingElse() {...}


   void ~MyWapper()
   {
        DoSomethingNoMatterWhat();
   }
}

void MainMethod()
{
    bool ok = myWrapper.DoSomething();
    if (!ok)
        _log.Error("Oops");
        return;
    }
    ok = myWrapper.DoSomethingElse();
    if (!ok)
       _log.Error("Oops");
        return;
    }
}
//DoSomethingNoMatterWhat will be called when myWrapper is destroyed

繰り返しますが、オブジェクトのライフサイクルを必ず理解してください。

オプション5.言語トリック：短絡評価を使用する

別の手法は、短絡評価を利用することです。

if (DoSomething1() && DoSomething2() && DoSomething3())
{
    DoSomething4();
}
DoSomethingNoMatterWhat();

このソリューションでは、&&演算子の機能を利用しています。&&の左側がfalseと評価された場合、右側は評価されません。

このトリックは、コンパクトなコードが必要な場合や、よく知られているアルゴリズムを実装している場合など、コードがあまりメンテナンスを必要としない場合に最も役立ちます。より一般的なコーディングでは、このコードの構造は非常に脆弱です。ロジックを少し変更しただけでも、完全な書き換えが発生する可能性があります。

するだけ

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

とても簡単です。

それぞれが根本的に質問を変更した3つの編集（バージョン1へのリビジョンを数えれば4つ）のため、私が回答しているコード例を含めます。

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

executeThisFunctionInAnyCase();

実際には、C ++でアクションを延期する方法があります。オブジェクトのデストラクタを利用することです。

C ++ 11にアクセスできると仮定します。

class Defer {
public:
    Defer(std::function<void()> f): f_(std::move(f)) {}
    ~Defer() { if (f_) { f_(); } }

    void cancel() { f_ = std::function<void()>(); }

private:
    Defer(Defer const&) = delete;
    Defer& operator=(Defer const&) = delete;

    std::function<void()> f_;
}; // class Defer

そして、そのユーティリティを使用します：

int foo() {
    Defer const defer{&executeThisFunctionInAnyCase}; // or a lambda

    // ...

    if (!executeA()) { return 1; }

    // ...

    if (!executeB()) { return 2; }

    // ...

    if (!executeC()) { return 3; }

    // ...

    return 4;
} // foo

returnステートメント（Itjaxで規定されているメソッド）で追加のラッパー関数を必要としない素晴らしいテクニックがあります。それはdo while(0)疑似ループを利用します。while (0)それは実際にループではなく、一度だけ実行することを保証します。ただし、ループ構文では、breakステートメントを使用できます。

void foo()
{
  // ...
  do {
      if (!executeStepA())
          break;
      if (!executeStepB())
          break;
      if (!executeStepC())
          break;
  }
  while (0);
  // ...
}

これを行うこともできます：

bool isOk = true;
std::vector<bool (*)(void)> funcs; //vector of function ptr

funcs.push_back(&executeStepA);
funcs.push_back(&executeStepB);
funcs.push_back(&executeStepC);
//...

//this will stop at the first false return
for (auto it = funcs.begin(); it != funcs.end() && isOk; ++it) 
    isOk = (*it)();
if (isOk)
 //doSomeStuff
executeThisFunctionInAnyCase();

このようにして、最小の線形拡張サイズ、1コールあたり+1行で、簡単にメンテナンスできます。

編集：（@Undaに感謝）IMOが見えなくなるため、大ファンではありません：

bool isOk = true;
auto funcs { //using c++11 initializer_list
    &executeStepA,
    &executeStepB,
    &executeStepC
};

for (auto it = funcs.begin(); it != funcs.end() && isOk; ++it) 
    isOk = (*it)();
if (isOk)
 //doSomeStuff
executeThisFunctionInAnyCase();

これはうまくいくでしょうか？これはあなたのコードと同等だと思います。

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

希望のコードが私が現在見ているものであると仮定します：

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();

これは避けどんなの必要性gotoの、例外、ダミーwhileのループ、またはその他の困難な構造をして単に手で簡単な仕事を持つになります。

breakステートメントは何らかの方法で使用できますか？

最善の解決策ではないかもしれませんが、ステートメントをdo .. while (0)ループに入れて、のbreak代わりにステートメント を使用できますreturn。

すべてのif条件を独自の関数に好きなようにフォーマットして置くと、戻り時にexecuteThisFunctionInAnyCase()関数が実行されます。

OPの基本的な例から、条件のテストと実行を分割することができます。

void InitialSteps()
{
  bool conditionA = executeStepA();
  if (!conditionA)
    return;
  bool conditionB = executeStepB();
  if (!conditionB)
    return;
  bool conditionC = executeStepC();
  if (!conditionC)
    return;
}

そして、そのように呼ばれました。

InitialSteps();
executeThisFunctionInAnyCase();

C ++ 11ラムダが利用可能な場合（OPにC ++ 11タグはありませんでしたが、それらはオプションである可能性があります）、別の関数を省略して、これをラムダにラップできます。

// Capture by reference (variable access may be required)
auto initialSteps = [&]() {
  // any additional code
  bool conditionA = executeStepA();
  if (!conditionA)
    return;
  // any additional code
  bool conditionB = executeStepB();
  if (!conditionB)
    return;
  // any additional code
  bool conditionC = executeStepC();
  if (!conditionC)
    return;
};

initialSteps();
executeThisFunctionInAnyCase();

ループが嫌いgotoで嫌いでdo { } while (0);C ++を使いたい場合は、一時的なラムダを使用して同じ効果を得ることができます。

[&]() { // create a capture all lambda
  if (!executeStepA()) { return; }
  if (!executeStepB()) { return; }
  if (!executeStepC()) { return; }
}(); // and immediately call it

executeThisFunctionInAnyCase();

コード内のIF / ELSEのチェーンは言語の問題ではなく、プログラムの設計です。プログラムをリファクタリングまたは書き直すことができる場合は、デザインパターン（http://sourcemaking.com/design_patterns）を調べてより良い解決策を見つけることをお勧めします。

通常、コードに多くのIFとその他のものがある場合、それは戦略デザインパターン（http://sourcemaking.com/design_patterns/strategy/c-sharp-dot-net）またはおそらく組み合わせを実装する機会です他のパターンの。

if / elseの長いリストを書く代替案があると私は確信していますが、チェーンがあなたにきれいに見えることを除いて、それらが何かを変えるとは思えません（ただし、美しさはまだコードに適用されますあまりにも:-)）。あなたは次のようなことを心配する必要があります（新しい状態があり、このコードについて何も覚えていない6か月以内に、私は簡単にコードを追加できますか？または、チェーンが変更された場合、どのくらい迅速かつエラーフリーか？実装しますか）

あなたはこれをします

coverConditions();
executeThisFunctionInAnyCase();

function coverConditions()
 {
 bool conditionA = executeStepA();
 if (!conditionA) return;
 bool conditionB = executeStepB();
 if (!conditionB) return;
 bool conditionC = executeStepC();
 if (!conditionC) return;
 }

100の99回です。これが唯一の方法です。

コンピュータコードで「トリッキー」なことをしようとすることは決してありません。

ちなみに、あなたが考えていた実際の解決策は次のとおりです...

継続ステートメントはアルゴリズムのプログラミングに重要です。（アルゴリズムプログラミングでは、gotoステートメントが重要です。）

多くのプログラミング言語でこれを行うことができます：

-(void)_testKode
    {
    NSLog(@"code a");
    NSLog(@"code b");
    NSLog(@"code c\n");
    
    int x = 69;
    
    {
    
    if ( x == 13 )
        {
        NSLog(@"code d---\n");
        continue;
        }
    
    if ( x == 69 )
        {
        NSLog(@"code e---\n");
        continue;
        }
    
    if ( x == 13 )
        {
        NSLog(@"code f---\n");
        continue;
        }
    
    }
    
    NSLog(@"code g");
    }

（まず最初に注意：その例のようなネイキッドブロックは、特に「アルゴリズム」プログラミングを扱っている場合は、美しいコードを書く上で重要かつ重要な部分です。）

もう一度、それは まさにあなたの頭の中にあったものですよね？そしてそれはそれを書くための美しい方法なので、あなたは良い本能を持っています。

ただし、悲劇的なことに、objective-cの現在のバージョンでは（さておき、Swiftについてはわかりません）には、囲んでいるブロックがループであるかどうかをチェックするリスクのある機能があります。

これを回避する方法は次のとおりです...

-(void)_testKode
    {
    NSLog(@"code a");
    NSLog(@"code b");
    NSLog(@"code c\n");
    
    int x = 69;
    
    do{
    
    if ( x == 13 )
        {
        NSLog(@"code d---\n");
        continue;
        }
    
    if ( x == 69 )
        {
        NSLog(@"code e---\n");
        continue;
        }
    
    if ( x == 13 )
        {
        NSLog(@"code f---\n");
        continue;
        }
    
    }while(false);
    
    NSLog(@"code g");
    }

ですので、忘れないでください。

{} while（false）;を実行します。

「このブロックを1回実行する」という意味です。

つまり、書くことdo{}while(false);と単に書くことの間に全く違いはありません{}。

これは今あなたが望むように完全に機能します...これが出力です...

だから、それはあなたが頭の中でアルゴリズムを見る方法である可能性があります。あなたはいつも頭の中にあるものを書くように努めるべきです。（特にあなたが冷静でない場合、それはかなりが出てくるときです！:)）

これが頻繁に発生する「アルゴリズム」プロジェクトでは、objective-cには常に次のようなマクロがあります...

#define RUNONCE while(false)

...だから、これを行うことができます...

-(void)_testKode
    {
    NSLog(@"code a");
    int x = 69;
    
    do{
    if ( x == 13 )
        {
        NSLog(@"code d---\n");
        continue;
        }
    if ( x == 69 )
        {
        NSLog(@"code e---\n");
        continue;
        }
    if ( x == 13 )
        {
        NSLog(@"code f---\n");
        continue;
        }
    }RUNONCE
    
    NSLog(@"code g");
    }

2つのポイントがあります。

a、objective-cがcontinueステートメントが含まれているブロックのタイプをチェックするのは愚かですが、「それと戦う」のは面倒です。だから、それは難しい決断です。

b、例では、そのブロックをインデントする必要があるという質問がありますか？私はそのような質問で眠りを失うので、アドバイスはできません。

それが役に立てば幸い。

実行関数が失敗した場合、falseを返す代わりに例外をスローします。次に、呼び出しコードは次のようになります。

try {
    executeStepA();
    executeStepB();
    executeStepC();
}
catch (...)

もちろん、元の例では、ステップ内でエラーが発生した場合にのみ実行ステップがfalseを返すと想定していますか？

すでに多くの良い答えがありますが、それらのほとんどは柔軟性のいくつか（確かにごくわずか）をトレードオフしているようです。このトレードオフを必要としない一般的なアプローチは、ステータス/キープゴーイング変数を追加することです。もちろん、価格は追跡するための1つの追加の値です。

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;

C ++（質問にはCとC ++の両方のタグが付けられています）で、例外を使用するように関数を変更できない場合でも、次のような小さなヘルパー関数を作成すると、例外メカニズムを使用できます。

struct function_failed {};
void attempt(bool retval)
{
  if (!retval)
    throw function_failed(); // or a more specific exception class
}

次に、コードは次のように読み取ることができます。

try
{
  attempt(executeStepA());
  attempt(executeStepB());
  attempt(executeStepC());
}
catch (function_failed)
{
  // -- this block intentionally left empty --
}

executeThisFunctionInAnyCase();

派手な構文に興味がある場合は、代わりに明示的なキャストで機能させることができます。

struct function_failed {};
struct attempt
{
  attempt(bool retval)
  {
    if (!retval)
      throw function_failed();
  }
};

次に、コードを次のように書くことができます

try
{
  (attempt) executeStepA();
  (attempt) executeStepB();
  (attempt) executeStepC();
}
catch (function_failed)
{
  // -- this block intentionally left empty --
}

executeThisFunctionInAnyCase();

コードが例のように単純で、言語が短絡評価をサポートしている場合、これを試すことができます。

StepA() && StepB() && StepC() && StepD();
DoAlways();

関数に引数を渡して他の結果を取得し、以前の方法でコードを記述できない場合は、他の多くの答えが問題に適しています。

C ++ 11以降では、Dのscope（exit）メカニズムと同様のスコープ出口システムを実装するのが良い方法です。

これを実装する1つの可能な方法は、C ++ 11ラムダといくつかのヘルパーマクロを使用することです。

template<typename F> struct ScopeExit 
{
    ScopeExit(F f) : fn(f) { }
    ~ScopeExit() 
    { 
         fn();
    }

    F fn;
};

template<typename F> ScopeExit<F> MakeScopeExit(F f) { return ScopeExit<F>(f); };

#define STR_APPEND2_HELPER(x, y) x##y
#define STR_APPEND2(x, y) STR_APPEND2_HELPER(x, y)

#define SCOPE_EXIT(code)\
    auto STR_APPEND2(scope_exit_, __LINE__) = MakeScopeExit([&](){ code })

これにより、関数から早期に戻り、定義したクリーンアップコードがスコープの終了時に常に実行されるようにすることができます。

SCOPE_EXIT(
    delete pointerA;
    delete pointerB;
    close(fileC); );

if (!executeStepA())
    return;

if (!executeStepB())
    return;

if (!executeStepC())
    return;

マクロは本当に単なる装飾です。MakeScopeExit()直接使用できます。

なぜ誰も最も簡単な解決策を与えていないのですか？：D

すべての関数に同じシグネチャがある場合は、次のようにすることができます（C言語の場合）。

bool (*step[])() = {
    &executeStepA,
    &executeStepB,
    &executeStepC,
    ... 
};

for (int i = 0; i < numberOfSteps; i++) {
    bool condition = step[i]();

    if (!condition) {
        break;
    }
}

executeThisFunctionInAnyCase();

クリーンなC ++ソリューションの場合、executeメソッドを含み、ステップをオブジェクトにラップするインターフェースクラスを作成する必要 があります。
次に、上記のソリューションは次のようになります。

Step *steps[] = {
    stepA,
    stepB,
    stepC,
    ... 
};

for (int i = 0; i < numberOfSteps; i++) {
    Step *step = steps[i];

    if (!step->execute()) {
        break;
    }
}

executeThisFunctionInAnyCase();

個別の条件変数は必要ないと仮定すると、テストを反転し、「ok」パスとしてelse-falthroughを使用すると、より垂直な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();

失敗した変数を省略すると、コードがIMOを少しあいまいにします。

内部で変数を宣言するのは問題ありません。= 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();

これは状態マシンのように見えます。これは、state-patternで簡単に実装できるので便利です。

Javaでは次のようになります。

interface StepState{
public StepState performStep();
}

実装は次のように機能します。

class StepA implements StepState{ 
    public StepState performStep()
     {
         performAction();
         if(condition) return new StepB()
         else return null;
     }
}

等々。次に、big if条件を次のように置き換えることができます。

Step toDo = new StepA();
while(toDo != null)
      toDo = toDo.performStep();
executeThisFunctionInAnyCase();

Rommikが述べたように、これにデザインパターンを適用できますが、呼び出しをチェーンしたいので、Strategyではなく、Decoratorパターンを使用します。コードが単純な場合は、入れ子にならないように、うまく構造化された回答の1つを使用します。ただし、複雑な場合や動的なチェーンが必要な場合は、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;
    }
}

デザインパターンについて読むのに最適な本、IMHOはHead First Design Patternsです。

いくつかの回答は、特にネットワークプログラミングで、私が何度も目にして使用したパターンをほのめかしました。ネットワークスタックでは、多くの場合、要求のシーケンスが長く、そのいずれかが失敗してプロセスが停止する可能性があります。

一般的なパターンは使用することでした do { } while (false);

私while(false)はそれを作るためにマクロを使用しましたdo { } once;一般的なパターンは：

do
{
    bool conditionA = executeStepA();
    if (! conditionA) break;
    bool conditionB = executeStepB();
    if (! conditionB) break;
    // etc.
} while (false);

このパターンは比較的読みやすく、適切に破壊するオブジェクトを使用できるようになり、複数の戻りを回避してステップとデバッグを少し簡単にしました。

MathieuのC ++ 11の回答を改善し、の使用によって発生する実行時のコストを回避するstd::functionには、次を使用することをお勧めします

template<typename functor>
class deferred final
{
public:
    template<typename functor2>
    explicit deferred(functor2&& f) : f(std::forward<functor2>(f)) {}
    ~deferred() { this->f(); }

private:
    functor f;
};

template<typename functor>
auto defer(functor&& f) -> deferred<typename std::decay<functor>::type>
{
    return deferred<typename std::decay<functor>::type>(std::forward<functor>(f));
}

この単純なテンプレートクラスは、パラメーターなしで呼び出すことができるファンクターを受け入れ、動的メモリ割り当てなしで受け入れるため、不必要なオーバーヘッドなしでC ++の抽象化の目標により適切に準拠します。追加の関数テンプレートは、テンプレートパラメーターの控除による使用を簡略化するためにあります（クラステンプレートパラメーターでは使用できません）

使用例：

auto guard = defer(executeThisFunctionInAnyCase);
bool conditionA = executeStepA();
if (!conditionA) return;
bool conditionB = executeStepB();
if (!conditionB) return;
bool conditionC = executeStepC();
if (!conditionC) return;

マシューの回答と同じように、このソリューションは完全に例外安全でありexecuteThisFunctionInAnyCase、すべての場合に呼び出されます。必要がありexecuteThisFunctionInAnyCase、それ自体は、デストラクタが暗黙のうちにマークされ、投げるnoexceptので、呼び出しがするstd::terminateスタックアンワインド中にスローされる例外を発生させたのではなく、発行されます。

1つのブロックからすべての呼び出しを実行したいようです。他の人がそれを提案したように、whileループを使用して去るか、breakまたは去ることができる新しい関数を使用する必要がありますreturnあります（よりクリーンな場合があります）。

私は個人的に追放する goto、関数の出口であってもします。デバッグ時にそれらを見つけるのは困難です。

ワークフローで機能するエレガントな代替手段は、関数配列を作成してこれを反復することです。

const int STEP_ARRAY_COUNT = 3;
bool (*stepsArray[])() = {
   executeStepA, executeStepB, executeStepC
};

for (int i=0; i<STEP_ARRAY_COUNT; ++i) {
    if (!stepsArray[i]()) {
        break;
    }
}

executeThisFunctionInAnyCase();

[...コードのブロック...]もあるので実行と実行の間に、メモリ割り当てまたはオブジェクトの初期化があると思います。このようにして、終了時に初期化済みのすべてをクリーンアップすることに注意する必要があり、問題が発生していずれかの関数がfalseを返す場合もクリーンアップする必要があります。

この場合、私の経験（CryptoAPIで作業したとき）で最も良かったのは、小さなクラスを作成することでした。コンストラクターでデータを初期化し、デストラクターでデータを初期化解除しました。次の各関数クラスは、前の関数クラスの子である必要があります。何か問題が発生した場合-例外をスローします。

class CondA
{
public:
    CondA() { 
        if (!executeStepA()) 
            throw int(1);
        [Initialize data]
    }
    ~CondA() {        
        [Clean data]
    }
    A* _a;
};

class CondB : public CondA
{
public:
    CondB() { 
        if (!executeStepB()) 
            throw int(2);
        [Initialize data]
    }
    ~CondB() {        
        [Clean data]
    }
    B* _b;
};

class CondC : public CondB
{
public:
    CondC() { 
        if (!executeStepC()) 
            throw int(3);
        [Initialize data]
    }
    ~CondC() {        
        [Clean data]
    }
    C* _c;
};

そして、あなたのコードではあなたは呼び出すだけです：

shared_ptr<CondC> C(nullptr);
try{
    C = make_shared<CondC>();
}
catch(int& e)
{
    //do something
}
if (C != nullptr)
{
   C->a;//work with
   C->b;//work with
   C->c;//work with
}
executeThisFunctionInAnyCase();

ConditionXのすべての呼び出しが何かを初期化し、メモリを割り当てるなどの場合は、それが最善のソリューションだと思います。すべてが確実にクリーンアップされるようにするのが最善です。

興味深い方法は、例外を処理することです。

try
{
    executeStepA();//function throws an exception on error
    ......
}
catch(...)
{
    //some error handling
}
finally
{
    executeThisFunctionInAnyCase();
}

そのようなコードを書いた場合、どういうわけか間違った方向に進んでいます。私はそれをそのようなコードを持つことの「問題」とは考えませんが、そのような厄介な「アーキテクチャ」を持つことはできません。

ヒント：これらのケースについては、信頼できる経験豊富な開発者と話し合ってください;-)

別のアプローチ- do - whileループ、それが前に述べられていたとしても、それがどのように見えるかを示すその例はありませんでした：

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

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

executeThisFunctionInAnyCase();

_{（まあループにはすでに答えがありwhileますが、do - whileループは真に（開始時に）冗長にチェックしませんが、代わりにxDの終わりに（これはスキップできます））。}