Priorité de l'opérateur par rapport à L'ordre D'évaluation

Oui, l'article MSDN est dans l'erreur, au moins à l'égard de la norme C et C++ ¹ .

cela dit, Permettez-moi de commencer par une note sur la terminologie: dans la norme C++, ILS (surtout--il y a quelques erreurs) utilisent" évaluation "pour se référer à l'évaluation d'un opérande, et" calcul de valeur " pour se référer à la réalisation d'une opération. Ainsi, lorsque (par exemple) vous faites a + b , chacun de a et b est évalué, alors le la valeur de calcul est réalisé pour déterminer le résultat.

il est clair que l'ordre des calculs de valeur est (principalement) contrôlé par la préséance et l'associativité-le contrôle des calculs de valeur est essentiellement la définition de ce que la préséance et l'associativité sont . Le reste de cette réponse utilise le terme "évaluation" pour désigner l'évaluation des opérandes, et non pour évaluer les calculs.

maintenant, quant à l'ordre d'évaluation étant déterminé par la préséance, non ce n'est pas! C'est aussi simple que cela. Prenons par exemple votre exemple de x<y<z . Selon les règles de l'associativité, cela signifie (x<y)<z . Maintenant, envisagez d'évaluer cette expression sur une machine à empiler. Il est parfaitement permis de faire quelque chose comme cela:

 push(z);    // Evaluates its argument and pushes value on stack
 push(y);
 push(x);
 test_less();  // compares TOS to TOS(1), pushes result on stack
 test_less();

cette évaluation évalue z avant x ou y , mais évalue encore (x<y) , puis compare le résultat de cette comparaison avec z , comme prévu.

résumé: L'ordre d'évaluation est indépendant de l'associativité.

priorité est la même. Nous pouvons changer l'expression à x*y+z , et encore évaluer z avant x ou y :

push(z);
push(y);
push(x);
mul();
add();

résumé: L'ordre d'évaluation est indépendant de la préséance.

quand / si nous ajoutons des effets secondaires, ceci reste le même. Je pense que c'est éducatif de penser aux effets secondaires comme étant effectués par un fil d'exécution séparé, avec un join au point de séquence suivant (par exemple, la fin de l'expression). Donc quelque chose comme a=b++ + ++c; pourrait être exécuté quelque chose comme ceci:

push(a);
push(b);
push(c+1);
side_effects_thread.queue(inc, b);
side_effects_thread.queue(inc, c);
add();
assign();
join(side_effects_thread);

cela montre aussi pourquoi une dépendance apparente n'affecte pas nécessairement l'ordre d'évaluation non plus. Même si a est la cible de la mission, ce encore évaluer a avant évaluer soit b ou c . Notez également que bien que je l'ai écrit comme "thread" ci-dessus, cela pourrait aussi bien être un pool de threads, tous exécutés en parallèle, de sorte que vous ne recevez aucune garantie sur l'ordre d'un incrément par rapport à un autre.

sauf si le matériel avait un support direct (et cheap ) pour la file d'attente sans fil, cela ne serait probablement pas utilisé dans une implémentation réelle (et même alors ce n'est pas très probable). Mettre quelque chose dans une file d'attente de thread-safe aura normalement un peu plus de frais généraux que de faire un seul incrément, il est donc difficile d'imaginer quelqu'un jamais faire cela dans la réalité. Conceptuellement, cependant, l'idée est conforme aux exigences de la NORME: Lorsque vous utilisez une opération de pré/post incrément/décrément, vous spécifiez une opération qui se produira un peu plus tard que cette partie de l'expression est évaluation et sera terminée au prochain point de séquence.

Edit: bien que ce ne soit pas exactement threading, certaines architectures permettent une telle exécution en parallèle. Pour un couple d'exemples, les processeurs Intel Itanium et VLIW comme certains DSPs, permettent à un compilateur de désigner un certain nombre d'instructions à exécuter en parallèle. La plupart des machines VLIW ont une taille d'instruction "paquet" spécifique qui limite le nombre d'instructions exécutées en parallèle. L'Itanium utilise également paquets d'instructions, mais désigne un bit dans un paquet d'instructions pour dire que les instructions du paquet courant peuvent être exécutées en parallèle avec celles du paquet suivant. En utilisant des mécanismes comme celui-ci, vous obtenez des instructions d'exécution en parallèle, tout comme si vous utilisiez plusieurs threads sur des architectures avec lesquelles la plupart d'entre nous sont plus familiers.

résumé: L'ordre d'évaluation est indépendant des dépendances apparentes

toute tentative d'utiliser la valeur avant le prochain point de séquence donne un comportement non défini -- en particulier, "l'autre thread "est (potentiellement) modifier ces données pendant ce temps, et vous avez Non façon de synchroniser l'accès avec l'autre thread. Toute tentative de l'utiliser conduit à un comportement non défini.

juste pour un exemple (certes, maintenant assez tiré par les cheveux), pensez à votre code qui tourne sur une machine virtuelle 64 bits, mais le vrai matériel est un processeur 8 bits. Lorsque vous incrémentez une variable 64-bit, il exécute une séquence quelque chose comme:

load variable[0]
increment
store variable[0]
for (int i=1; i<8; i++) {
    load variable[i]
    add_with_carry 0
    store variable[i]
}

si vous lisez la valeur quelque part au milieu de cette séquence, vous pouvez obtenir quelque chose avec seulement quelques octets modifiés, donc ce que vous obtenez n'est ni l'ancienne valeur ni la nouvelle.

cet exemple précis peut être assez tiré par les cheveux, mais une version moins extrême (par exemple, une variable 64 bits sur une machine 32 bits) est en fait assez commun.

Conclusion

de l'Ordre d'évaluation n' pas dépend de la priorité, l'associativité, ou (forcément) sur l'apparente dépendances. Tenter d'utiliser une variable à laquelle un incrément/décrément pré/post a été appliqué dans n'importe quelle autre partie d'une expression donne vraiment complètement comportement non défini. Bien qu'un véritable accident soit peu probable, vous êtes certainement pas la garantie d'obtenir soit l'ancien ou le nouveau -- vous pourriez trouver quelque chose d'autre entièrement.

¹ Je n'ai pas vérifié cet article en particulier, mais un bon nombre d'articles de MSDN parlent de C++ et/ou C++/CLI gérés par Microsoft (ou sont spécifiques à leur implémentation de C++) mais font peu ou rien pour souligner qu'ils ne s'appliquent pas à la norme C ou C++. Cela peut donner l'apparence fausse qu'ils prétendent le les règles qu'ils ont décidé d'appliquer à leurs propres langues réellement s'appliquer à la norme langues. Dans ces cas, les articles ne sont pas techniquement faux -- ils n'ont tout simplement rien à voir avec le standard C ou C++. Si vous tentez d'appliquer ces énoncés à la norme C ou c++, le résultat est faux.