int [] arr = {0}; valeur int = arr [arr [0] ++]; Valeur = 1?

Question

Aujourd'hui, je suis tombé sur un article de Eric Lippert où il essayait d'effacer le mythe entre la priorité des opérateurs et l'ordre d'évaluation. A la fin, il y avait deux extraits de code qui me suis embrouillé, voici le premier extrait:

 int[] arr = {0}; 
     int value = arr[arr[0]++]; 

Maintenant, quand je pense à la valeur de la variable, je calcule simplement l'un. Voici comment je pensais que ça fonctionnait.

1. d'abord déclarer arr comme un tableau d'int avec un élément à l'intérieur de celui-ci; cette valeur de l'élément est 0.
2. Deuxième obtenir la valeur de arr [0] - 0 dans ce cas.
3. Troisième obtenir la valeur de arr [la valeur de l'étape 2] (qui est encore 0) --gets arr [0] à nouveau --still 0.
4. quatrième affecter la valeur de l'étape 3 (0) à la valeur de la variable. --value = 0 maintenant
5. Ajouter à la valeur de l'étape 2 1 --Now arr [0] = 1.

Apparemment, cela est faux. J'ai essayé de rechercher les spécifications C# pour une déclaration explicite sur le moment où l'incrément est en train de se produire, mais je n'en ai trouvé aucun.
Le deuxième extrait est d'un commentaire d'Eric de blog post sur le sujet:

int[] data = { 11, 22, 33 }; 
int i = 1; 
data[i++] = data[i] + 5; 

est maintenant ici que je pense que ce programme exécutera --after déclarant le tableau et l'attribution d'1 à i. [Plz ours avec moi]

1. Obtenir des données [i] --1
2. Ajouter à la valeur de l'étape 1 la valeur 5 --6
3. Assigner aux données [i] (ce qui est encore 1) la valeur de l'étape 2 --data [i] = 6
4. i Increment - i = 2

Selon ma compréhension, ce tableau doit maintenant contenir les valeurs {11, 27 , 33}. Cependant, quand j'ai bouclé pour imprimer les valeurs de tableau que j'ai: {11, 38, 33}. Cela signifie que l'incrément post s'est produit avant de déréférencer le tableau!
Comment ça se fait? Ce post-incrément n'est-il pas censé être post? C'est-à-dire après tout le reste.
Qu'est-ce qui me manque les gars?

Answer 1

L'opération post-incrémentation intervient dans le cadre de l'évaluation de l'expression globale. C'est un effet secondaire qui survient après l'évaluation de la valeur mais avant que toutes les autres expressions ne soient évaluées.

En d'autres termes, pour toute expression E, E ++ (si légal) représente quelque chose comme (pseudo-code):

T tmp = E; 
E += 1; 
return tmp; 

C'est tout partie de l'évaluation E ++, avant toute autre chose est évaluée.

Voir la section 7.5.9 de la spécification C# 3.0 pour plus de détails.

---

De plus, pour les opérations d'affectation où le LHS est classé comme une variable (comme dans ce cas), le LHS est évalué avant l'ERS est évaluée.

Donc, dans votre exemple:

int[] data = { 11, 22, 33 }; 
int i = 1; 
data[i++] = data[i] + 5; 

équivaut à:

int[] data = { 11, 22, 33 }; 
int i = 1; 
// Work out what the LHS is going to mean... 
int index = i; 
i++; 
// We're going to assign to data[index], i.e. data[1]. Now i=2. 

// Now evaluate the RHS 
int rhs = data[i] + 5; // rhs = data[2] + 5 == 38 

// Now assign: 
data[index] = rhs; 

Le bit correspondant du cahier des charges de cette section est 7.16.1 (spec C# 3.0).

Answer 2

data[i++] // => data[1], then i is incremented to 2 

data[1] = data[2] + 5 // => 33 + 5 

Answer 3

La cause peut être que certains compilateurs optimisent i ++ pour être ++ i. La plupart du temps, le résultat final est le même, mais il me semble être l'une de ces rares occasions où le compilateur a tort.

Je n'ai pas encore accès à Visual Studio pour le confirmer, mais essayez de désactiver l'optimisation du code et de voir si les résultats resteront les mêmes.

Answer 4

Je m'attendrais à ce que l'opérateur de post-incrémentation incrémente la variable après que sa valeur soit utilisée. Dans ce cas, la variable est incrémentée avant la deuxième référence à la variable.

Si ce ne serait pas, vous pouvez écrire

data[i++] = data[i++] + data[i++] + data[i++] + 5 

Si ce serait comme vous le dites, alors vous pouvez supprimer l'opérateur d'incrémentation, car il ne fait pas vraiment quoi que ce soit, dans l'instruction je l'ai signalé .

Answer 5

Pour le premier fragment, dont la séquence est la suivante:

1. déclarer arr comme vous décrit:
2. récupérer la valeur d'arr [0], qui est égal à 0
3. incrémenter la valeur du arr [0 ] à 1.
4. Récupérer la valeur arr [(résultat # 2)] qui est arr [0], qui (per # 3) est égal à 1.
5. magasin qui se traduisent par value.
6. value = 1

Pour le second extrait, l'évaluation est toujours de gauche à droite.

1. Où stockons-nous le résultat? Dans les données [i ++], qui sont des données [1], mais maintenant i = 2
2. Qu'ajoutons-nous?data [i] + 5, qui est maintenant data [2] + 5, qui est 38.

La pièce manquante est que "post" ne signifie pas "après TOUT autre chose". Cela signifie simplement "immédiatement après avoir récupéré la valeur actuelle de cette variable". Un post-incrément se produisant "au milieu" d'une ligne de code est tout à fait normal.

Answer 6

Vous devez penser des affectations en trois étapes:

1. Évaluer le côté gauche (= get adresse où la valeur doit être stockée)
2. Évaluer côté main droite
3. Affecte la valeur de l'étape 2 à l'emplacement de mémoire à l'étape 1.

Si vous avez quelque chose comme

A().B = C() 

Ensuite, A() s'exécutera en premier, puis C() s'exécutera, puis le paramètre B de la propriété sera exécuté.

Essentiellement, vous devez penser à votre déclaration

StoreInArray(data, i++, data[i] + 5);