Supondo que eu tenho esse pseudo-código:

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

executeThisFunctionInAnyCase();

As funções executeStepXdevem ser executadas se e somente se as anteriores tiverem êxito. De qualquer forma, a executeThisFunctionInAnyCasefunção deve ser chamada no final. Sou iniciante em programação, desculpe-me pela pergunta muito básica: existe uma maneira (em C / C ++, por exemplo) de evitar tanto tempo?if cadeia produzindo esse tipo de "pirâmide de código", às custas da legibilidade do código ?

Eu sei que se pudéssemos pular a executeThisFunctionInAnyCasechamada de função, o código poderia ser simplificado como:

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

Mas a restrição é a executeThisFunctionInAnyCasechamada de função. A breakdeclaração poderia ser usada de alguma maneira?

Você pode usar um &&(AND lógico):

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

isso atenderá a ambos os seus requisitos:

• executeStep<X>()deve avaliar apenas se o anterior foi bem-sucedido (isso é chamado de avaliação de curto-circuito )
• executeThisFunctionInAnyCase() será executado em qualquer caso

Basta usar uma função adicional para que sua segunda versão funcione:

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

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

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

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

Usar ifs profundamente aninhados (sua primeira variante) ou o desejo de interromper "parte de uma função" geralmente significa que você precisa de uma função extra.

Os programadores da velha escola C usam gotoneste caso. É o único uso gotoincentivado pelo guia de estilo do Linux, chamado de saída de função centralizada:

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;
}

Algumas pessoas trabalham em torno do uso gotoenvolvendo o corpo em um loop e quebrando-o, mas efetivamente as duas abordagens fazem a mesma coisa. A gotoabordagem é melhor se você precisar de alguma outra limpeza somente se executeStepA()for bem-sucedida:

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;
}

Com a abordagem de loop, você acabaria com dois níveis de loops nesse caso.

Esta é uma situação comum e há muitas maneiras comuns de lidar com isso. Aqui está minha tentativa de resposta canônica. Por favor, comente se eu perdi alguma coisa e vou manter esta postagem atualizada.

Esta é uma flecha

O que você está discutindo é conhecido como anti-padrão de seta . É chamada de seta porque a cadeia de ifs aninhados forma blocos de código que se expandem cada vez mais para a direita e depois para a esquerda, formando uma seta visual que "aponta" para o lado direito do painel do editor de código.

Achate a flecha com a guarda

Algumas maneiras comuns de evitar o Arrow são discutidas aqui . O método mais comum é usar um padrão de guarda , no qual o código lida primeiro com os fluxos de exceção e depois lida com o fluxo básico, por exemplo, em vez de

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

... você usaria ....

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

Quando houver uma longa série de guardas, isso achatará o código consideravelmente, pois todos os guardas aparecem totalmente à esquerda e seus ifs não estão aninhados. Além disso, você está visualizando o emparelhamento visual da condição lógica com o erro associado, o que torna muito mais fácil saber o que está acontecendo:

Seta:

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;
}

Guarda:

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;
} 

É objetiva e quantificável mais fácil de ler, porque

1. Os caracteres {e} para um determinado bloco lógico estão mais próximos
2. A quantidade de contexto mental necessária para entender uma linha específica é menor
3. A totalidade da lógica associada a uma condição if é mais provável que esteja em uma página
4. A necessidade de o codificador rolar a página / trilha ocular diminui bastante

Como adicionar código comum no final

O problema com o padrão de guarda é que ele se baseia no que é chamado de "retorno oportunista" ou "saída oportunista". Em outras palavras, ele quebra o padrão de que toda e qualquer função deve ter exatamente um ponto de saída. Este é um problema por dois motivos:

1. Isso atrapalha algumas pessoas da maneira errada, por exemplo, pessoas que aprenderam a codificar em Pascal aprenderam que uma função = um ponto de saída.
2. Ele não fornece uma seção de código que é executada na saída, independentemente do assunto , que é o assunto em questão.

Abaixo, forneci algumas opções para contornar essa limitação, usando os recursos de idioma ou evitando o problema completamente.

Opção 1. Você não pode fazer isso: use finally

Infelizmente, como desenvolvedor de c ++, você não pode fazer isso. Mas esta é a resposta número um para idiomas que contêm finalmente uma palavra-chave, pois é exatamente para isso que serve.

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

Opção 2. Evite o problema: reestruture suas funções

Você pode evitar o problema dividindo o código em duas funções. Esta solução tem o benefício de trabalhar para qualquer idioma e, além disso, pode reduzir a complexidade ciclomática , que é uma maneira comprovada de reduzir a taxa de defeitos e melhora a especificidade de qualquer teste de unidade automatizado.

Aqui está um exemplo:

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

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

Opção 3. Truque de idiomas: use um loop falso

Outro truque comum que vejo é usar while (true) e break, como mostrado nas outras respostas.

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

Embora isso seja menos "honesto" do que usado goto, é menos propenso a ser confuso ao refatorar, pois marca claramente os limites do escopo da lógica. Um codificador ingênuo que corta e cola seus rótulos ou suas gotodeclarações pode causar grandes problemas! (E, francamente, o padrão é tão comum agora, acho que comunica claramente a intenção e, portanto, não é "desonesto").

Existem outras variantes dessas opções. Por exemplo, um poderia usar em switchvez de while. Qualquer construção de idioma com uma breakpalavra - chave provavelmente funcionaria.

Opção 4. Aproveite o ciclo de vida do objeto

Uma outra abordagem aproveita o ciclo de vida do objeto. Use um objeto de contexto para carregar seus parâmetros (algo que nosso exemplo ingênuo desconfia) e descartá-lo quando terminar.

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
}

Nota: Certifique-se de entender o ciclo de vida do objeto de seu idioma preferido. Você precisa de algum tipo de coleta de lixo determinística para que isso funcione, ou seja, você precisa saber quando o destruidor será chamado. Em alguns idiomas, você precisará usar em Disposevez de um destruidor.

Opção 4.1. Aproveite o ciclo de vida do objeto (padrão de wrapper)

Se você usar uma abordagem orientada a objetos, pode fazê-lo corretamente. Esta opção usa uma classe para "agrupar" os recursos que requerem limpeza, bem como suas outras operações.

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

Novamente, certifique-se de entender o seu ciclo de vida do objeto.

Opção 5. Truque de idiomas: use avaliação de curto-circuito

Outra técnica é tirar proveito da avaliação de curto-circuito .

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

Esta solução tira proveito da maneira como o operador && funciona. Quando o lado esquerdo de && é avaliado como falso, o lado direito nunca é avaliado.

Esse truque é mais útil quando o código compacto é necessário e quando o código provavelmente não recebe muita manutenção, por exemplo, você está implementando um algoritmo conhecido. Para uma codificação mais geral, a estrutura desse código é muito frágil; mesmo uma pequena alteração na lógica pode desencadear uma reescrita total.

Apenas faça

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

É simples assim.

Devido a três edições em que cada uma mudou fundamentalmente a pergunta (quatro se uma conta a revisão de volta à versão 1), incluo o exemplo de código ao qual estou respondendo:

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

executeThisFunctionInAnyCase();

Na verdade, existe uma maneira de adiar ações no C ++: fazendo uso do destruidor de um objeto.

Supondo que você tenha acesso ao 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

E então usando esse utilitário:

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

    // ...

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

    // ...

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

    // ...

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

    // ...

    return 4;
} // foo

Existe uma boa técnica que não precisa de uma função adicional do wrapper com as instruções de retorno (o método prescrito pelo Itjax). Utiliza um while(0)pseudo-loop do. Os while (0)garante que ele não é realmente um laço, mas executados apenas uma vez. No entanto, a sintaxe do loop permite o uso da instrução break.

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

Você também pode fazer isso:

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

Dessa forma, você tem um tamanho de crescimento linear mínimo, uma linha por chamada e é facilmente sustentável.

EDIT : (Obrigado @Unda) Não é um grande fã porque você perde visibilidade 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();

Isso funcionaria? Eu acho que isso é equivalente ao seu código.

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

Supondo que o código desejado seja o que eu vejo atualmente:

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

Eu diria que a abordagem correta, na medida em que é mais simples de ler e mais fácil de manter, teria menos níveis de indentação, que é (atualmente) o objetivo declarado da questão.

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

Isso evita qualquer necessidade de gotos, exceções, whileloops fictícios ou outras construções difíceis e simplesmente continua o trabalho simples em mãos.

A declaração de quebra poderia ser usada de alguma maneira?

Talvez não seja a melhor solução, mas você pode colocar suas instruções em um do .. while (0)loop e usar breakinstruções em vez de return.

Você pode colocar todas as ifcondições, formatadas como você deseja, em uma função própria, para o retorno executar a executeThisFunctionInAnyCase()função.

No exemplo base do OP, o teste e a execução da condição podem ser divididos como tal;

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

E então chamado como tal;

InitialSteps();
executeThisFunctionInAnyCase();

Se lambdas C ++ 11 estiverem disponíveis (não havia tag C ++ 11 no OP, mas elas ainda podem ser uma opção), podemos renunciar à função separada e agrupá-la em uma lambda.

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

Se você não gosta gotoe não gosta de do { } while (0);loops e gosta de usar C ++, também pode usar um lambda temporário para ter o mesmo efeito.

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

executeThisFunctionInAnyCase();

As cadeias de IF / ELSE no seu código não são o problema de idioma, mas o design do seu programa. Se você é capaz de re-fatorar ou reescrever seu programa, gostaria de sugerir que você procure em Design Patterns ( http://sourcemaking.com/design_patterns ) para encontrar uma solução melhor.

Normalmente, quando você vê muitos FIs e outros itens no seu código, é uma oportunidade de implementar o Padrão de Design da Estratégia ( http://sourcemaking.com/design_patterns/strategy/c-sharp-dot-net ) ou talvez uma combinação de outros padrões.

Tenho certeza de que existem alternativas para escrever uma longa lista de if / else, mas duvido que elas mudem tudo, exceto que a cadeia ficará bonita para você (no entanto, a beleza está nos olhos de quem vê ainda se aplica ao código também:-) ) . Você deve se preocupar com coisas como (em 6 meses quando eu tiver uma nova condição e não me lembro de nada sobre esse código, poderei adicioná-lo facilmente? Ou, se a cadeia mudar, com que rapidez e sem erros serei implementado)

Você acabou de fazer isso ..

coverConditions();
executeThisFunctionInAnyCase();

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

99 vezes de 100, esta é a única maneira de fazê-lo.

Nunca, jamais, tente fazer algo "complicado" no código do computador.

By the way, eu tenho certeza que o seguinte é a solução real que você tinha em mente ...

A instrução continue é crítica na programação algorítmica. (Tanto quanto, a instrução goto é crítica na programação algorítmica.)

Em muitas linguagens de programação, você pode fazer isso:

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

(Observe antes de tudo: blocos simples como esse exemplo são uma parte crítica e importante da escrita de códigos bonitos, principalmente se você estiver lidando com programação "algorítmica".)

Novamente, é exatamente isso que você tinha em sua cabeça, certo? E essa é a maneira bonita de escrever, para que você tenha bons instintos.

No entanto, tragicamente, na versão atual do objetivo-c (além disso - não conheço o Swift, desculpe), há um recurso que pode ser subido onde ele verifica se o bloco envolvente é um loop.

Aqui está como você contorna isso ...

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

Então não esqueça disso ..

faça {} enquanto (falso);

significa apenas "faça este bloco uma vez".

ou seja, não há absolutamente nenhuma diferença entre escrever do{}while(false);e simplesmente escrever {}.

Isso agora funciona perfeitamente como você queria ... aqui está a saída ...

Então, é possível que seja assim que você vê o algoritmo em sua cabeça. Você deve sempre tentar escrever o que está na sua cabeça. (Particularmente se você não estiver sóbrio, porque é aí que a bonita sai! :))

Em projetos "algorítmicos", onde isso acontece muito, no objetivo-c, sempre temos uma macro como ...

#define RUNONCE while(false)

... então você pode fazer isso ...

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

Existem dois pontos:

a, mesmo que seja estúpido que o objetivo-c verifique o tipo de bloco em que uma instrução continue está, é preocupante "lutar contra isso". Portanto, é uma decisão difícil.

b, existe a pergunta que você deve recuar, no exemplo, nesse bloco? Eu perco o sono com perguntas assim, então não posso aconselhar.

Espero que ajude.

Faça com que suas funções de execução gerem uma exceção se falharem em vez de retornar falso. Em seguida, seu código de chamada pode ficar assim:

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

É claro que estou assumindo que, no seu exemplo original, a etapa de execução retornaria falsa apenas no caso de um erro ocorrer dentro da etapa?

Já existem muitas boas respostas, mas a maioria delas parece compensar parte (reconhecidamente muito pouco) da flexibilidade. Uma abordagem comum que não exige essa troca é a adição de uma variável de status / manutenção . O preço é, obviamente, um valor extra para acompanhar:

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;

No C ++ (a pergunta está marcada como C e C ++), se você não pode alterar as funções para usar exceções, ainda pode usar o mecanismo de exceção se escrever uma pequena função auxiliar como

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

Em seguida, seu código pode ler da seguinte maneira:

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

executeThisFunctionInAnyCase();

Se você gosta de sintaxe sofisticada, pode fazê-lo funcionar por meio de conversão explícita:

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

Então você pode escrever seu código como

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

executeThisFunctionInAnyCase();

Se seu código é tão simples quanto o seu exemplo e seu idioma suporta avaliações de curto-circuito, você pode tentar o seguinte:

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

Se você estiver passando argumentos para suas funções e recuperando outros resultados para que seu código não possa ser gravado da maneira anterior, muitas das outras respostas seriam mais adequadas ao problema.

Para C ++ 11 e além, uma boa abordagem pode ser a implementação de um sistema de saída de escopo semelhante ao mecanismo de escopo (saída) de D.

Uma maneira possível de implementá-lo é usar C ++ 11 lambdas e algumas macros auxiliares:

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 })

Isso permitirá que você retorne mais cedo da função e garanta que qualquer código de limpeza definido seja sempre executado na saída do escopo:

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

if (!executeStepA())
    return;

if (!executeStepB())
    return;

if (!executeStepC())
    return;

As macros são realmente apenas decoração. MakeScopeExit()pode ser usado diretamente.

Por que ninguém está dando a solução mais simples? : D

Se todas as suas funções tiverem a mesma assinatura, você poderá fazê-lo desta maneira (no idioma C):

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

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

    if (!condition) {
        break;
    }
}

executeThisFunctionInAnyCase();

Para uma solução C ++ limpa, você deve criar uma classe de interface que contenha um método execute e agrupe suas etapas em objetos.
Em seguida, a solução acima terá a seguinte aparência:

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

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

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

executeThisFunctionInAnyCase();

Supondo que você não precise de variáveis ​​de condição individuais, inverter os testes e usar o else-falthrough como o caminho "ok" permitiria obter um conjunto mais vertical de instruções 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();

Omitir a variável com falha torna o código um pouco IMO obscuro.

Declarar as variáveis ​​internas é bom, não se preocupe com = 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();

Isso é obscuro, mas compacto:

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

runThisFunctionInAnyCase();

Parece uma máquina de estado, o que é útil porque você pode implementá-la facilmente com um padrão de estado .

Em Java, seria algo parecido com isto:

interface StepState{
public StepState performStep();
}

Uma implementação funcionaria da seguinte maneira:

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

E assim por diante. Em seguida, você pode substituir a condição big if por:

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

Como Rommik mencionou, você pode aplicar um padrão de design para isso, mas eu usaria o padrão Decorator em vez de Strategy, pois você deseja encadear chamadas. Se o código for simples, eu usaria uma das respostas bem estruturadas para evitar o aninhamento. No entanto, se for complexo ou exigir encadeamento dinâmico, o padrão Decorator é uma boa opção. Aqui está um diagrama de classes yUML :

Aqui está um exemplo de programa 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;
    }
}

O melhor livro para ler sobre padrões de design, IMHO, é Head First Design Patterns .

Várias respostas sugeriram um padrão que eu vi e usei muitas vezes, especialmente em programação de rede. Nas pilhas de rede, geralmente há uma longa sequência de solicitações, qualquer uma das quais pode falhar e interromper o processo.

O padrão comum era usar do { } while (false);

Eu usei uma macro para while(false)fazê-lo do { } once;O padrão comum era:

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

Esse padrão era relativamente fácil de ler e permitia o uso de objetos que destruíam adequadamente e também evitavam vários retornos, facilitando um pouco a etapa e a depuração.

Para melhorar a resposta C ++ 11 de Mathieu e evitar o custo de tempo de execução incorrido com o uso de std::function, sugiro usar o seguinte

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

Essa classe de modelo simples aceita qualquer functor que possa ser chamado sem nenhum parâmetro e o faz sem alocações dinâmicas de memória e, portanto, está melhor em conformidade com o objetivo de abstração do C ++ sem sobrecarga desnecessária. O modelo de função adicional existe para simplificar o uso pela dedução de parâmetro do modelo (que não está disponível para os parâmetros do modelo de classe)

Exemplo de uso:

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

Assim como a resposta de Mathieu, esta solução é totalmente segura contra exceções e executeThisFunctionInAnyCaseserá chamada em todos os casos. Deveria executeThisFunctionInAnyCaselançar, os destruidores são implicitamente marcados noexcepte, portanto, uma chamada para std::terminateseria emitida em vez de causar uma exceção a ser lançada durante o desenrolamento da pilha.

Parece que você deseja fazer todas as suas ligações em um único bloco. Como outros propuseram, você deve usar um whileloop e deixar de usar breakou uma nova função com a qual possa sair return(pode ser mais limpo).

Eu pessoalmente banir goto, mesmo para a saída da função. Eles são mais difíceis de detectar ao depurar.

Uma alternativa elegante que deve funcionar para o seu fluxo de trabalho é criar uma matriz de funções e iterar nessa.

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

Como você também tem um bloco de [...] código entre execuções, acho que você tem alocação de memória ou inicialização de objeto. Dessa forma, você precisa se preocupar em limpar tudo o que você já inicializou na saída e também limpá-lo se encontrar algum problema e qualquer uma das funções retornar falso.

Nesse caso, o melhor que eu tive na minha experiência (quando trabalhei com o CryptoAPI) foi criar pequenas classes, no construtor você inicializa seus dados, no destruidor você o inicializa. Cada próxima classe de função deve ser filha da classe de função anterior. Se algo der errado - lance uma exceção.

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;
};

E então, no seu código, você só precisa chamar:

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

Eu acho que é a melhor solução se cada chamada do ConditionX inicializar algo, alocar memória e etc. Melhor garantir que tudo será limpo.

uma maneira interessante é trabalhar com exceções.

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

Se você escrever esse código, está indo de alguma forma na direção errada. Não considero "o problema" ter esse código, mas ter uma "arquitetura" tão confusa.

Dica: discuta esses casos com um desenvolvedor experiente no qual você confia ;-)

Outra abordagem - do - whileloop, apesar de ter sido mencionado antes, não havia nenhum exemplo disso que mostrasse como ele se parece:

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

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

executeThisFunctionInAnyCase();

_{(Bem, já existe uma resposta com whileloop, mas o do - whileloop não verifica redundantemente se é verdade (no início), mas no final xD (isso pode ser ignorado).}