Les opérateurs logiques de court-circuit sont-ils obligatoires? Et ordre d'évaluation?

La norme ANSI mandat à court-circuiter les opérateurs logiques, en C ou C ++?

Je suis confus car je me souviens du livre K&R disant que votre code ne devrait pas dépendre du court-circuit de ces opérations, car elles peuvent ne pas l'être. Quelqu'un pourrait-il indiquer où dans la norme il est dit que les opérations logiques sont toujours court-circuitées? Je suis surtout intéressé par C ++, une réponse également pour C serait géniale.

Je me souviens aussi avoir lu (je ne me souviens pas où) que l'ordre d'évaluation n'est pas strictement défini, donc votre code ne devrait pas dépendre ou assumer que les fonctions d'une expression seraient exécutées dans un ordre spécifique: à la fin d'une instruction, toutes les fonctions référencées aura été appelé, mais le compilateur a la liberté de sélectionner l'ordre le plus efficace.

La norme indique-t-elle l'ordre d'évaluation de cette expression?

if( functionA() && functionB() && functionC() ) cout<<"Hello world";

Oui, un court-circuit et un ordre d'évaluation sont requis pour les opérateurs ||et &&dans les normes C et C ++.

La norme C ++ dit (il devrait y avoir une clause équivalente dans la norme C):

1.9.18

Dans l'évaluation des expressions suivantes

a && b
a || b
a ? b : c
a , b

en utilisant la signification intégrée des opérateurs dans ces expressions, il y a un point de séquence après l'évaluation de la première expression (12).

En C ++, il y a un piège supplémentaire: le court-circuit ne s'applique PAS aux types qui surchargent les opérateurs ||et &&.

Note de bas de page 12: Les opérateurs indiqués dans ce paragraphe sont les opérateurs intégrés, comme décrit dans l'article 5. Lorsqu'un de ces opérateurs est surchargé (article 13) dans un contexte valide, désignant ainsi une fonction d'opérateur définie par l'utilisateur, l'expression désigne une invocation de fonction, et les opérandes forment une liste d'arguments, sans point de séquence implicite entre eux.

Il n'est généralement pas recommandé de surcharger ces opérateurs en C ++, sauf si vous avez une exigence très spécifique. Vous pouvez le faire, mais cela peut interrompre le comportement attendu dans le code d'autres personnes, en particulier si ces opérateurs sont utilisés indirectement via des modèles d'instanciation avec le type surchargeant ces opérateurs.

L'évaluation des courts-circuits et l'ordre d'évaluation sont une norme sémantique obligatoire en C et C ++.

Si ce n'était pas le cas, un code comme celui-ci ne serait pas un idiome courant

   char* pChar = 0;
   // some actions which may or may not set pChar to something
   if ((pChar != 0) && (*pChar != '\0')) {
      // do something useful

   }

La section 6.5.13 Opérateur ET logique de la spécification C99 (lien PDF) dit

(4). Contrairement à l'opérateur binaire & au niveau du bit, l'opérateur && garantit une évaluation de gauche à droite; il y a un point de séquence après l'évaluation du premier opérande. Si le premier opérande est égal à 0, le deuxième opérande n'est pas évalué.

De même, la section 6.5.14 Opérateur logique OR dit

(4) Contrairement au bitwise | opérateur, le || l'opérateur garantit une évaluation de gauche à droite; il y a un point de séquence après l'évaluation du premier opérande. Si le premier opérande n'est pas égal à 0, le deuxième opérande n'est pas évalué.

Des termes similaires peuvent être trouvés dans les normes C ++, consultez la section 5.14 de ce projet de copie . Comme les vérificateurs le notent dans une autre réponse, si vous remplacez && ou ||, les deux opérandes doivent être évalués car ils deviennent un appel de fonction normal.

Oui, cela l'exige (ordre d'évaluation et court-circuit). Dans votre exemple, si toutes les fonctions retournent true, l'ordre des appels est strictement à partir de functionA puis functionB puis functionC. Utilisé pour cela comme

if(ptr && ptr->value) { 
    ...
}

Idem pour l'opérateur virgule:

// calls a, then b and evaluates to the value returned by b
// which is used to initialize c
int c = (a(), b()); 

On dit entre la gauche et la droite opérande &&, ||, ,et entre le premier et le deuxième / troisième opérande ?:(opérateur conditionnel) est un « point de séquence ». Tous les effets secondaires sont évalués complètement avant ce point. Donc, c'est sûr:

int a = 0;
int b = (a++, a); // b initialized with 1, and a is 1

Notez que l'opérateur virgule ne doit pas être confondu avec la virgule syntaxique utilisée pour séparer les choses:

// order of calls to a and b is unspecified!
function(a(), b());

La norme C ++ dit dans 5.14/1:

L'opérateur && regroupe de gauche à droite. Les opérandes sont tous deux implicitement convertis en type bool (clause 4). Le résultat est vrai si les deux opérandes sont vrai et faux dans le cas contraire. Contrairement à &, && garantit une évaluation de gauche à droite: le deuxième opérande n'est pas évalué si le premier opérande est faux.

Et dans 5.15/1:

Le || groupes d'opérateurs de gauche à droite. Les opérandes sont tous deux implicitement convertis en booléen (clause 4). Il renvoie vrai si l'un de ses opérandes est vrai et faux dans le cas contraire. Contrairement à |, || garantit une évaluation de gauche à droite; de plus, le deuxième opérande n'est pas évalué si le premier opérande est évalué à vrai.

Il dit pour les deux à côté de ceux-ci:

Le résultat est un booléen. Tous les effets secondaires de la première expression, à l'exception de la destruction des temporaires (12.2), se produisent avant que la seconde expression ne soit évaluée.

En plus de cela, 1.9/18dit

Dans l'évaluation de chacune des expressions

• a && b
• a || b
• a ? b : C
• a , b

en utilisant la signification intégrée des opérateurs dans ces expressions (5.14, 5.15, 5.16, 5.18), il y a un point de séquence après l'évaluation de la première expression.

Tout droit sorti du bon vieux K&R:

C garantit cela &&et ||sont évalués de gauche à droite - nous verrons bientôt des cas où cela compte.

Soyez très très prudent.

Pour les types fondamentaux, il s'agit d'opérateurs de raccourcis.

Mais si vous définissez ces opérateurs pour vos propres types de classe ou d'énumération, ils ne sont pas des raccourcis. En raison de cette différence sémantique dans leur utilisation dans ces différentes circonstances, il est recommandé de ne pas définir ces opérateurs.

Pour les types fondamentaux operator &&et operator ||pour les types fondamentaux, l'ordre d'évaluation est de gauche à droite (sinon un raccourci serait difficile :-) Mais pour les opérateurs surchargés que vous définissez, il s'agit essentiellement de sucre syntaxique pour définir une méthode et donc l'ordre d'évaluation des paramètres est indéfini.

Votre question se résume à la priorité des opérateurs C ++ et à l'associativité. Fondamentalement, dans les expressions avec plusieurs opérateurs et sans parenthèses, le compilateur construit l'arborescence des expressions en suivant ces règles.

Pour la priorité, lorsque vous avez quelque chose comme A op1 B op2 C, vous pouvez regrouper les éléments sous la forme soit (A op1 B) op2 Cou A op1 (B op2 C). Si op1a une priorité plus élevée que op2, vous obtiendrez la première expression. Sinon, vous obtiendrez le deuxième.

Pour l'associativité, lorsque vous avez quelque chose comme A op B op C, vous pouvez à nouveau regrouper les minces comme (A op B) op Cou A op (B op C). Si opa quitté l'associativité, on se retrouve avec la première expression. S'il a la bonne associativité, on se retrouve avec la seconde. Cela fonctionne également pour les opérateurs au même niveau de priorité.

Dans ce cas particulier, &&a une priorité plus élevée que ||, donc l'expression sera évaluée comme (a != "" && it == seqMap.end()) || isEven.

L'ordre lui-même est "de gauche à droite" sur la forme d'arbre d'expression. Nous allons donc d'abord évaluer a != "" && it == seqMap.end(). Si c'est vrai, toute l'expression est vraie, sinon on passe à isEven. La procédure se répète de manière récursive dans la sous-expression de gauche bien sûr.

Quelques informations intéressantes, mais le concept de priorité a ses racines dans la notation mathématique. La même chose se produit dans a*b + c, où *a une priorité plus élevée que +.

Encore plus intéressant / obscur, pour une expression sans parenté A1 op1 A2 op2 ... opn-1 An, où tous les opérateurs ont la même priorité, le nombre d'arbres d'expressions binaires que nous pourrions former est donné par les nombres dits catalans . Pour les grands n, ceux-ci se développent extrêmement rapidement. ré

Si vous faites confiance à Wikipédia:

[ &&et ||] sont sémantiquement distincts des opérateurs binaires & et | car ils n'évalueront jamais l'opérande de droite si le résultat peut être déterminé à partir de la seule gauche

C (langage de programmation)