Comportement des opérateurs avant et après incrémentation en C, C ++, Java et C #

Question

AVERTISSEMENT: Ce n'est pas un exemple du monde réel. Ce n'est qu'une question théorique sur le fonctionnement de ces langues.

Quelles sont exactement les différences entre C / C ++, C # et Java en ce qui concerne les opérateurs de post-incrémentation?

C’est ce que j’obtiens avec VC ++ 10, Java 1.6 et C # 4

 int a = 2;
int b = a++ + a++;
int c = ++a + a++ + a++;

      +-----+------+------+----+
      |  C  | C++  | Java | C# |
+-----+-----+------+------+----+
| a   |  7  |  7   |   7  |  7 |
+-----+-----+------+------+----+
| b   |  4  |  4   |   5  | 5  |
+-----+-----+------+------+----+
| c   | 15  |  15  |  16  | 16 |
+-----+-----+------+------+----+
 

Answer 1

Java et C # évaluent les expressions de gauche à droite et les effets secondaires sont visibles immédiatement .

En C ++, l'ordre d'évaluation des sous-expressions n'est pas spécifié et la modification du même objet deux fois sans point de séquence intermédiaire correspond à un comportement indéfini.

Answer 2

Je n'ai pas le temps de rédiger une description détaillée des différences entre C++, C, C# et Java. Je me contenterai de dire que le C# comportement de la pré-et post-incrémentation des opérateurs est entièrement spécifié (single-threaded scénarios; si vous voulez savoir à propos de son atomicité, des garanties sur les observations de lire et d'écrire les commandes multi-processeur de la faiblesse des modèles de mémoire et ainsi de suite, vous êtes sur votre propre à faire de la recherche.) Il n'est pas complètement définie en C et C++; un compilateur a une large latitude de faire ce qu'il lui plaît avec ré-ordonnancement des effets secondaires. Je n'ai jamais utilisé Java donc je ne vais pas spéculer sur ce que Java n'.

Pour plus d'informations sur ce que le C# n', vous devriez lire la spécification C#. Pour un court laps de prendre sur elle, lire ma réponse à cette question:

C#: quelle est la différence entre i++ et ++i?

Pour un effet encore plus courte:

Les sous-expressions en C# expression sont logiquement regroupés par priorité et associativité des opérateurs, et ensuite évalués de gauche à droite , peu importe. (Ainsi, par exemple, A() + B() * C() évalue Un(), alors B(), alors C(). Le fait que la multiplication "vient avant" le plus est sans importance; les sous-expressions sont toujours évaluées de gauche à droite.)

Si l'évaluation d'une sous-expression provoque un effet secondaire en raison d'un pré ou de post-incrémentation sous-expression alors l'effet secondaire se produit immédiatement avant le résultat est produit.

Answer 3

En C ++, il s'agit d'un comportement non défini. Toute réponse est donc correcte. Voir Points de comportement et de séquence non définis pour plus de détails.

Pas sûr des autres langues, mais je m'attendrais à ce que ce code soit incorrect là aussi.

MODIFIER:
Voir la réponse d'Eric Lippert à propos de C #. Il réfute mon hypothèse concernant le comportement de C #.

Answer 4

En C ++ au moins ce comportement indéfini. Citant le standard C ++:

"Entre les points de séquence précédent et suivant, la valeur stockée d'un objet scalaire doit être modifiée au plus une fois par l'évaluation d'une expression."

Answer 5

La Java du modèle de mémoire garantit l'ordre, les charges et les magasins sont faites, de sorte qu'il devrait sortir le même quel que soit la JVM (je crois).

Il ressemble au C++ a le même ordre d'opérations, mais une fois que vous l'utiliser deux fois sur une ligne, vous commencez à courir dans l'autre substance (Vlad est à droite). Si vous essayez d'autres compilateurs C++, vous pouvez trouver qu'ils viennent avec des réponses différentes.

Je suis sûr que C# a le même ordre d'opérations, mais ma conjecture est qu'ils ont une mémoire de modèle (comme Java) qui assure la cohérence, mais je n'ai pas beaucoup de connaissances ici.