Instruction if - évaluation de court-circuit vs lisibilité

Parfois, une ifinstruction peut être assez compliquée ou longue, donc pour des raisons de lisibilité, il est préférable d'extraire les appels compliqués avant le if.

par exemple ceci:

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

dans ce

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

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

(l'exemple fourni n'est pas si mal, c'est juste à titre d'illustration ... imaginez d'autres appels avec plusieurs arguments, etc.)

Mais avec cette extraction, j'ai perdu l'évaluation des courts-circuits (SCE).

1. Est-ce que je perds vraiment SCE à chaque fois? Existe-t-il un scénario dans lequel le compilateur est autorisé à «l'optimiser» tout en fournissant SCE?
2. Existe-t-il des moyens de conserver la lisibilité améliorée du deuxième extrait de code sans perdre SCE?

Une solution naturelle ressemblerait à ceci:

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

if (bn)
{
  // do stuff
}

Cela présente les avantages d'être facile à comprendre, d'être applicable à tous les cas et d'avoir un comportement de court-circuit.

C'était ma solution initiale: un bon modèle dans les appels de méthode et les corps de boucle for est le suivant:

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

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

// do stuff

On obtient les mêmes avantages de performances que l'évaluation des courts-circuits, mais le code semble plus lisible.

J'ai tendance à décomposer les conditions sur plusieurs lignes, c'est-à-dire:

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

Même lorsque vous traitez avec plusieurs opérateurs (&&), il vous suffit d'avancer l'indentation avec chaque paire de parenthèses. SCE intervient toujours - pas besoin d'utiliser des variables. Écrire du code de cette façon me le rendait beaucoup plus lisible depuis des années déjà. Exemple plus complexe:

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

Si vous avez de longues chaînes de conditions et que conserver une partie du court-circuit, vous pouvez utiliser des variables temporaires pour combiner plusieurs conditions. En prenant votre exemple, il serait possible de faire par exemple

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

Si vous avez un compilateur compatible C ++ 11, vous pouvez utiliser des expressions lambda pour combiner des expressions en fonctions, comme ci-dessus:

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

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

1) Oui, vous n'avez plus SCE. Sinon, tu aurais ça

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

fonctionne dans un sens ou dans l'autre selon qu'il y a une ifdéclaration plus tard. Beaucoup trop complexe.

2) Ceci est basé sur une opinion, mais pour des expressions raisonnablement complexes, vous pouvez faire:

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

Si cela est trop complexe, la solution évidente est de créer une fonction qui évalue l'expression et l'appelle.

Vous pouvez aussi utiliser:

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

et SCE fonctionnera.

Mais ce n'est pas beaucoup plus lisible que par exemple:

if (
    someComplicatedStuff()
    ||
    otherComplicatedStuff()
   )

1) Est-ce que je perds vraiment du SCE à chaque fois? Un scénario est-il autorisé au compilateur pour «l'optimiser» et toujours fournir SCE?

Je ne pense pas qu'une telle optimisation soit autorisée; surtout OtherComplicatedFunctionCall()pourrait avoir des effets secondaires.

2) Quelle est la meilleure pratique dans une telle situation? Est-ce seulement la possibilité (quand je veux SCE) d'avoir tout ce dont j'ai besoin directement à l'intérieur si et "formatez-le simplement pour qu'il soit aussi lisible que possible"?

Je préfère le refactoriser en une fonction ou une variable avec un nom descriptif; ce qui préservera à la fois l'évaluation des courts-circuits et la lisibilité:

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

...

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

Et lorsque nous implémentons en getSomeResult()fonction de SomeComplicatedFunctionCall()et OtherComplicatedFunctionCall(), nous pourrions les décomposer de manière récursive s'ils sont encore compliqués.

1) Est-ce que je perds vraiment du SCE à chaque fois? Un scénario est-il autorisé au compilateur pour «l'optimiser» et toujours fournir SCE?

Non, vous ne le faites pas, mais c'est appliqué différemment:

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

Ici, le compilateur ne s'exécutera même pas OtherComplicatedFunctionCall()s'il SomeComplicatedFunctionCall()retourne true.

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

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

Ici, les deux fonctions vont exécuter parce qu'ils doivent être stockés dans b1et b2. Ff b1 == truealors b2ne sera pas évalué (SCE). Mais OtherComplicatedFunctionCall()a déjà été exécuté.

Si b2n'est utilisé nulle part ailleurs, le compilateur peut être assez intelligent pour intégrer l'appel de fonction à l'intérieur du if si la fonction n'a pas d'effets secondaires observables.

2) Quelle est la meilleure pratique dans une telle situation? Est-ce seulement la possibilité (quand je veux SCE) d'avoir tout ce dont j'ai besoin directement à l'intérieur si et "formatez-le simplement pour qu'il soit aussi lisible que possible"?

Ça dépend. Avez-vous besoin OtherComplicatedFunctionCall() d'exécuter en raison d'effets secondaires ou si la performance de la fonction est minime, vous devez utiliser la deuxième approche pour la lisibilité. Sinon, tenez-vous-en à SCE par la première approche.

Une autre possibilité qui court-circuite et a les conditions en un seul endroit:

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

Vous pouvez mettre la boucle dans une fonction et laisser la fonction accepter une liste de conditions et afficher une valeur booléenne.

Très étrange: vous parlez de lisibilité lorsque personne ne mentionne l'utilisation du commentaire dans le code:

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

En plus de cela, je précède toujours mes fonctions avec quelques commentaires, sur la fonction elle-même, sur son entrée et sa sortie, et parfois je mets un exemple, comme vous pouvez le voir ici:

/*---------------------------*/
/*! 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)

Evidemment le formatage à utiliser pour vos commentaires peut dépendre de votre environnement de développement (Visual studio, JavaDoc sous Eclipse, ...)

En ce qui concerne SCE, je suppose que vous entendez par là ce qui suit:

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 lisibilité est nécessaire si vous travaillez dans une entreprise et votre code sera lu par quelqu'un d'autre. Si vous écrivez un programme pour vous-même, c'est à vous de décider si vous voulez sacrifier les performances au nom d'un code compréhensible.