Quelle est la différence entre X = X ++? vs X ++ ;?

Avez-vous déjà essayé cela auparavant?

static void Main(ssortingng[] args) { int x = 10; x = x++; Console.WriteLine(x); } 

Sortie: 10.

mais pour

 static void Main(ssortingng[] args) { int x = 10; x++; Console.WriteLine(x); } 

Sortie: 11.

Quelqu’un pourrait-il expliquer pourquoi cela?

X ++ incrémentera la valeur, mais renverra son ancienne valeur.

Donc dans ce cas:

 static void Main(ssortingng[] args) { int x = 10; x = x++; Console.WriteLine(x); } 

Vous avez X à 11 juste un instant, puis il revient à 10 car 10 est la valeur de retour de (x ++).

Vous pourriez plutôt faire ceci pour le même résultat:

 static int plusplus(ref int x) { int xOld = x; x++; return xOld; } static void Main(ssortingng[] args) { int x = 10; x = plusplus(x); Console.WriteLine(x); } 

Il convient également de mentionner que vous auriez le résultat attendu de 11 si vous aviez fait:

 static void Main(ssortingng[] args) { int x = 10; x = ++x; Console.WriteLine(x); } 

Dans l’affectation x = x++ vous devez d’ abord extraire l’ancienne valeur de x pour évaluer l’expression du côté droit, dans ce cas «x»; ensuite, vous incrémentez x de 1. Enfin, vous affectez les résultats de l’évaluation de l’expression (10) à x via l’instruction d’affectation.

Peut-être qu’un code équivalent rendrait la situation plus claire:

 var tmp = x; x++; x = tmp; 

Ceci est l’équivalent de votre code x = x++ en C #.

Le comportement de x ++ consiste à incrémenter x mais à renvoyer la valeur avant l’incrément. C’est ce qu’on appelle un incrément de poste pour cette raison.

Donc x = x ++; mettre simplement la volonté

1. renvoyer la valeur , puis

2. incrémenter x , puis

3. assignez la valeur d’origine (retournée à l’étape 1) de x à x .

x = ++ x

serait égal à 11.

 x++; 

fait ce qui suit:

 int returnValue = x; x = x+1; return returnValue; 

Comme vous pouvez le voir, la valeur d’origine est enregistrée, x est incrémenté, puis la valeur d’origine est renvoyée.

Cela finit par sauver la valeur 10 quelque part, en définissant x égal à 11, puis en renvoyant 10, ce qui entraîne la remise à 10 de x. Notez que x devient effectivement 11 pendant quelques cycles (sans optimisation du compilateur) .

Cela ne répond pas directement à la question, mais pourquoi dans le monde quelqu’un utiliserait-il

 x = x++; 

?

Cela va totalement à l’encontre de l’objective de l’opérateur post-incrémentation / pré-incrémentation.

Vous pouvez y penser comme ceci:

 int x = 10; 

X est un conteneur et contient une valeur 10.

 x = x++; 

Cela peut être divisé en:

 1) increment the value contained in x now x contains 11 2) return the value that was contained in x before it was incremented that is 10 3) assign that value to x now, x contains 10 

Maintenant, imprimez la valeur contenue dans x

 Console.WriteLine(x); 

Et, sans surprise, il imprime 10.

Par définition, x ++ renvoie la valeur de x puis incrémente x.

http://blogs.msdn.com/lucabol/archive/2004/08/31/223580.aspx

La première chose que vous faites est appelée “post-incrémentation”, ce qui signifie que

  int x = 10; x++; //x still is 10 Console.WriteLine(x); //x is now 11(post increment) 

donc au moment où vous affectez x = x ++; x est toujours 10 ce que vous pourriez faire, si vous avez besoin de x 11 à cette ligne, écrivez ++ x (pensez que cela s’appelle pré-incrémenter corrigez-moi si je me trompe) … ou bien x ++; et que x = x ++;

question, est-ce que cela dépend de la ligne ou de l’énoncé, ce qui signifie qu’il va s’incrémenter après le; ?

Essayez d’appeler ++ x et voyez si cela fonctionne.

Mettre l’opérateur d’incrément après la variable signifie que l’incrément et l’affectation ont lieu après l’évaluation de l’expression … so L’instruction d’origine x = x ++; traduit en 1. Évaluez x et stockez la valeur dans la mémoire tyransient … Exécutez maintenant le code appelé par l’opérateur ++ … (étapes 2 et 3) 2. Incrémentez la valeur de x (dans la mémoire transitoire) 3. Atsortingbuez la valeur incrémentée à l’emplacement de stockage de x … Maintenant, continuez avec le rest de l’exécution de la ligne, à gauche, il y a un signe = … 5. Atsortingbuez donc la valeur stockée à l’étape 1 (valeur non incrémentée) à l’expression à gauche de = signe. qui est x

Peut-être que je n’ai pas raison, mais il est plus facile pour moi de comprendre le résultat sur un exemple similaire:

 public static void main(Ssortingng[] args) { int x = 10; int y = 0; y = x + x++; //1, 2, 3, 4 x += x; //5 System.out.println("x = " + x + "; y = " + y); //6 } 

Regardons l’opération y = x + x ++ pas à pas:

  1. Un ordinateur prend la valeur de x et l’ajoute à la valeur de x (10 + 10 = 20)
  2. L’ordinateur MET LE RÉSULTAT À UNE VARIABLE TEMPORAIRE (temp = 20)
  3. Le copieur incrémente x (10 + 1 = 11)
  4. L’ordinateur ASSIGNE LE RUSULT DE L’OPÉRATION DU CÔTÉ DROIT STOCKÉ EN temp à la variable y (20)
  5. Un ordinateur prend la valeur de x et l’ajoute à la valeur de x (11 + 11 = 22)
  6. Le résultat final est: x = 22; y = 20

Et maintenant, revenons à notre exemple et faisons les mêmes étapes:

 public static void main(Ssortingng[] args) { int x = 10; x = x++; //1, 2, 3, 4 System.out.println(x); //5 } 
  1. Un ordinateur prend la valeur de x (10)
  2. L’ordinateur MET LE RÉSULTAT À UNE VARIABLE TEMPORAIRE (temp = 10)
  3. Le copieur incrémente x (10 + 1 = 11)
  4. L’ordinateur ASSIGNE LE RUSULT DE L’OPÉRATION DU CÔTÉ DROIT STOCKÉ IN temp à la variable x (10)
  5. Le résultat final est: x = 10

Je sais qu’il y a beaucoup de réponses, et une réponse acceptée, mais je vais tout de même mettre mes deux centimes pour un autre sharepoint vue.

Je sais que cette question était C #, mais je suppose que pour quelque chose comme un opérateur postfix, il n’a pas un comportement différent de C:

 int main(){ int x = 0; while (x<1) x = x++; } 

L'assemblage (oui, je l'ai édité pour le rendre plus lisible) généré par le compilateur montre

 ... mov -8(rbp), 0 ; x = 0 L1: cmp -8(rbp), 1 ; if x >= 1, jge L2 ; leave the loop mov eax, -8(rbp) ; t1 = x mov ecx, eax ; t2 = t1 add ecx, 1 ; t2 = t2 + 1 mov -8(rbp), ecx ; x = t2 (so x = x + 1 !) mov -8(rbp), eax ; x = t1 (kidding, it's the original value again) jmp L1 L2: ... 

De manière équivalente, la boucle fait quelque chose comme:

 t = x x = x + 1 x = t 

Note: activer des optimisations vous donne un résultat d'assemblage comme celui-ci:

 ... L1: jmp L1 ... 

il ne prend même pas la peine de stocker la valeur que vous lui avez donné x!

En tant qu’instruction autonome, x++; est à la fois un incrément et une affectation. Il semble y avoir des confusions quant à ce qui se passe quand. Si nous avons

 int x = 10; int y = (x++) + 2; 

Nous aurons x = 11 et y = 12 . La valeur actuelle de x est atsortingbuée, puis l’incrément et la réaffectation de x ont lieu. Donc, en utilisant la même variable,

 int x = 10; // Create a variable x, and assign an initial value of 10. x = x++; // First, assign the current value of x to x. (x = x) // Second, increment x by one. (x++ - first part) // Third, assign the new value of x to x. (x++ - second part) 

De toute façon, la nouvelle valeur de x est 11.

Je me suis complètement trompé sur celui-là.

Explication simple:

x ++ est une incrémentation postfixe.

Qu’est-ce que le compilateur fait:

a) Atsortingbuez la valeur de x à x b) Augmentez la valeur temporaire de x (je suppose que cela peut être optimisé) c) Jetez la valeur temporaire de x

Si vous voulez que le code retourne 11 avec l’affectation, écrivez:

x = ++ x;

Le résultat de la mission

 x = x++; 

est indéfini en C et C ++ , et je devine la même chose avec C # aussi.

Ainsi, la séquence d’opérations réelle qui se produit dépend de la manière dont le compilateur décide de l’implémenter, il n’y a aucune garantie que l’affectation ou l’incrément se produise en premier. (Ceci est bien défini en C #, comme Jon Skeet l’a souligné dans les commentaires. Bien que je pense maintenant que cette réponse a beaucoup moins de valeur maintenant, je ne rends pas ce message pour la question du PO et sa réponse dans les commentaires.)

Cependant, dans ce cas, il semble que la séquence d’opérations qui se produit est la suivante:

  1. l’ancienne valeur (10) de x est enregistrée
  2. x est incrémenté pour la partie ++
  3. l’ancienne valeur est maintenant assignée à x pour l’affectation

De cette manière, bien que l’incrément ait lieu, il est dépassé par l’affectation avec l’ancienne valeur, conservant ainsi x à 10.

HTH