A maneira mais legível para formatar longas condições? [fechadas]

Geralmente, uma condição longa se é o sinal de código que precisa de refatoração, mas às vezes você não pode evitá-lo. Nesses casos, prefiro o primeiro:

if (bar || baz || quux) { ... }

Porque você é capaz de dizer o que está acontecendo com uma linha. No entanto, prefiro fazer algo assim, quando possível:

function foo() {
  return bar || baz || quux;
}

if (foo()) { ... }

Eu gosto de manter os operadores no final para indicar continuação:

if (the_function_being_called() != RETURNCODE_SUCCESS &&
    the_possibly_useful_recovery_strategy() == RETURNCODE_EPICFAIL &&
    this_user_has_elected_to_recieve_error_reports)
{
    report_error();
}

Sou muito fã de nomes de variáveis significativos:

const bool isInAStrangeCondition =
    FoobarBaz::quxQuux(corge, grault) ||
    !garply(waldo) ||
    fred(plugh) !== xyzzy;

if (isInAStrangeCondition) {
    thud();
}

Ou refatorar como uma função, como mencionado acima.

Eu quebro as subexpressões mais confusas, ou todas elas, como variáveis booleanas. Em seguida, a lógica booleana de nível superior da instrução 'if' pode ser esclarecida. No tipo de trabalho que faço, nem sempre são várias coisas ORed ou ANDed.

bool goodblah = some_mess < whatever;
bool frobnacious = messy_crud != junky_expression;
bool yetanother = long_winded_condition;

if (goodblah || (frobnacious && yetanother))   {
    ...
}

Isso é especialmente bom em um depurador, onde posso ver todos os bools antes de executar o 'if'.

Costumo alinhar os operadores no início de novas linhas, então lembro como estou combinando termos (tanto para lógica longa como para aritmética longa). Assim:

if (first_attempt(data) == SUCCESS
    || (reusable(data) && second_attempt(data) == SUCCESS)
    || (still_reusable(data) && third_attempt(data) == SUCCESS))
  return SUCCESS;

Isso só funciona se eu indentar por dois espaços ou definir meu ambiente para recuar mais predicados multilinha, ou então seria difícil dizer onde o predicado termina e o código útil começa.

Sou fã dos seguintes:

if (really_long_expression && another_really_really_long_expression && 
            another_very_long_expression_OMG_id_it_long){
    bugs();
}

Desta forma, ainda parece uma expressão if e não uma expressão if-down-to-pieces if. O recuo ajuda a mostrar que é uma continuação da linha anterior.

Você também pode recuá-lo até que o colchete de abertura esteja no final da linha anterior, de forma que esteja no final da expressão if como deveria ser.