declaración if - evaluación de cortocircuito frente a legibilidad

A veces, una ifdeclaración puede ser bastante complicada o larga, por lo que en aras de la legibilidad es mejor extraer las llamadas complicadas antes del if.

por ejemplo, esto:

if (SomeComplicatedFunctionCall() || OtherComplicatedFunctionCall())
{
    // do stuff
}

dentro de esto

bool b1 = SomeComplicatedFunctionCall();
bool b2 = OtherComplicatedFunctionCall();

if (b1 || b2)
{
    //do stuff
}

(proporcionado ejemplo no es que mal, es sólo para la ilustración ... imaginar otras llamadas con múltiples argumentos, etc.)

Pero con esta extracción perdí la evaluación de cortocircuito (SCE).

1. ¿De verdad pierdo SCE cada vez? ¿Existe algún escenario en el que el compilador pueda "optimizarlo" y seguir proporcionando SCE?
2. ¿Hay formas de mantener la legibilidad mejorada del segundo fragmento sin perder SCE?

Una solución natural se vería así:

bool b1 = SomeCondition();
bool b2 = b1 || SomeOtherCondition();
bool b3 = b2 || SomeThirdCondition();
// any other condition
bool bn = bn_1 || SomeFinalCondition();

if (bn)
{
  // do stuff
}

Esto tiene las ventajas de ser fácil de entender, aplicable a todos los casos y tener un comportamiento de cortocircuito.

Esta fue mi solución inicial: un buen patrón en llamadas a métodos y cuerpos de bucle for es el siguiente:

if (!SomeComplicatedFunctionCall())
   return; // or continue

if (!SomeOtherComplicatedFunctionCall())
   return; // or continue

// do stuff

Se obtienen los mismos beneficios de rendimiento de la evaluación de cortocircuitos, pero el código parece más legible.

Tiendo a dividir las condiciones en varias líneas, es decir:

if( SomeComplicatedFunctionCall()
 || OtherComplicatedFunctionCall()
  ) {

Incluso cuando se trata de varios operadores (&&), solo necesita hacer una sangría avanzada con cada par de paréntesis. SCE todavía entra en acción, no es necesario utilizar variables. Escribir código de esta manera me lo hizo mucho más legible desde hace años. Ejemplo más complejo:

if( one()
 ||( two()> 1337
  &&( three()== 'foo'
   || four()
    )
   )
 || five()!= 3.1415
  ) {

Si tiene largas cadenas de condiciones y qué mantener algunos de los cortocircuitos, entonces podría usar variables temporales para combinar múltiples condiciones. Tomando su ejemplo, sería posible hacer, por ejemplo,

bool b = SomeComplicatedFunctionCall() || OtherComplicatedFunctionCall();
if (b && some_other_expression) { ... }

Si tiene un compilador compatible con C ++ 11, puede usar expresiones lambda para combinar expresiones en funciones, similar a lo anterior:

auto e = []()
{
    return SomeComplicatedFunctionCall() || OtherComplicatedFunctionCall();
};

if (e() && some_other_expression) { ... }

1) Sí, ya no tiene SCE. De lo contrario, tendrías eso

bool b1 = SomeComplicatedFunctionCall();
bool b2 = OtherComplicatedFunctionCall();

funciona de una forma u otra dependiendo si hay una ifdeclaración más adelante. Demasiado complejo.

2) Esto se basa en opiniones, pero para expresiones razonablemente complejas puede hacer:

if (SomeComplicatedFunctionCall()
    || OtherComplicatedFunctionCall()) {

Si es demasiado complejo, la solución obvia es crear una función que evalúe la expresión y la llame.

También puedes usar:

bool b = someComplicatedStuff();
b = b || otherComplicatedStuff(); // it has to be: b = b || ...;  b |= ...; is bitwise OR and SCE is not working then 

y SCE funcionará.

Pero no es mucho más legible que, por ejemplo:

if (
    someComplicatedStuff()
    ||
    otherComplicatedStuff()
   )

1) ¿Realmente pierdo SCE cada vez? ¿Se permite al compilador algún escenario "optimizarlo" y seguir proporcionando SCE?

No creo que esta optimización esté permitida; especialmente OtherComplicatedFunctionCall()puede tener algunos efectos secundarios.

2) ¿Cuál es la mejor práctica en tal situación? ¿Es la única posibilidad (cuando quiero que SCE) tenga todo lo que necesito directamente dentro y "simplemente formatee para que sea lo más legible posible"?

Prefiero refactorizarlo en una función o una variable con un nombre descriptivo; que preservará tanto la evaluación de cortocircuitos como la legibilidad:

bool getSomeResult() {
    return SomeComplicatedFunctionCall() || OtherComplicatedFunctionCall();
}

...

if (getSomeResult())
{
    //do stuff
}

Y a medida que implementamos en getSomeResult()función de SomeComplicatedFunctionCall()y OtherComplicatedFunctionCall(), podríamos descomponerlos de forma recursiva si aún son complicados.

1) ¿Realmente pierdo SCE cada vez? ¿Se permite al compilador algún escenario "optimizarlo" y seguir proporcionando SCE?

No, no lo haces, pero se aplica de manera diferente:

if (SomeComplicatedFunctionCall() || OtherComplicatedFunctionCall())
{
    // do stuff
}

Aquí, el compilador ni siquiera se ejecutará OtherComplicatedFunctionCall()si SomeComplicatedFunctionCall()devuelve verdadero.

bool b1 = SomeComplicatedFunctionCall();
bool b2 = OtherComplicatedFunctionCall();

if (b1 || b2)
{
    //do stuff
}

Aquí, ambas funciones se ejecutarán porque deben almacenarse en b1y b2. Ff b1 == trueentonces b2no será evaluado (SCE). Pero ya OtherComplicatedFunctionCall()se ha ejecutado.

Si no b2se usa en ningún otro lugar, el compilador podría ser lo suficientemente inteligente como para insertar la llamada a la función dentro de if if la función no tiene efectos secundarios observables.

2) ¿Cuál es la mejor práctica en tal situación? ¿Es la única posibilidad (cuando quiero que SCE) tenga todo lo que necesito directamente dentro y "simplemente formatee para que sea lo más legible posible"?

Eso depende. ¿ Necesita OtherComplicatedFunctionCall() ejecutar debido a efectos secundarios o el impacto en el rendimiento de la función es mínimo? Entonces debe usar el segundo enfoque para mejorar la legibilidad. De lo contrario, apéguese a SCE en el primer enfoque.

Otra posibilidad de que se produzca un cortocircuito y tenga las condiciones en un solo lugar:

bool (* conditions [])()= {&a, &b, ...}; // list of conditions
bool conditionsHold = true;
for(int i= 0; i < sizeOf(conditions); i ++){
     if (!conditions[i]()){;
         conditionsHold = false;
         break;
     }
}
//conditionsHold is true if all conditions were met, otherwise false

Puede poner el ciclo en una función y dejar que la función acepte una lista de condiciones y genere un valor booleano.

Muy extraño: estás hablando de legibilidad cuando nadie menciona el uso de comentarios dentro del código:

if (somecomplicated_function() || // let me explain what this function does
    someother_function())         // this function does something else
...

Además de eso, siempre antecedo mis funciones con algunos comentarios, sobre la función en sí, sobre su entrada y salida, y a veces pongo un ejemplo, como puedes ver aquí:

/*---------------------------*/
/*! interpolates between values
* @param[in] X_axis : contains X-values
* @param[in] Y_axis : contains Y-values
* @param[in] value  : X-value, input to the interpolation process
* @return[out]      : the interpolated value
* @example          : interpolate([2,0],[3,2],2.4) -> 0.8
*/
int interpolate(std::vector<int>& X_axis, std::vector<int>& Y_axis, int value)

Obviamente, el formato a utilizar para sus comentarios puede depender de su entorno de desarrollo (Visual studio, JavaDoc bajo Eclipse, ...)

En lo que respecta a SCE, supongo que con esto se refiere a lo siguiente:

bool b1;
b1 = somecomplicated_function(); // let me explain what this function does
bool b2 = false;
if (!b1) {                       // SCE : if first function call is already true,
                                 // no need to spend resources executing second function.
  b2 = someother_function();     // this function does something else
}

if (b1 || b2) {
...
}

La legibilidad es necesaria si trabaja en una empresa y su código será leído por otra persona. Si escribe un programa para usted mismo, depende de usted si desea sacrificar el rendimiento en aras de un código comprensible.