Qual è la differenza tra X = X ++; vs X ++ ;?

Hai mai provato prima?

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

Uscita: 10.

ma per

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

Uscita: 11.

Qualcuno potrebbe spiegare perché questo?

X ++ incrementerà il valore, ma restituirà il suo vecchio valore.

Quindi in questo caso:

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

Hai X a 11 solo per un momento, poi torna a 10 perché 10 è il valore di ritorno di (x ++).

Potresti invece farlo per lo stesso risultato:

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

Vale anche la pena ricordare che avresti il ​​risultato previsto di 11 se avessi fatto:

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

Nell’assegnazione x = x++ estrai prima il vecchio valore di x da usare nella valutazione dell’espressione lato destro, in questo caso ‘x’; quindi, si incrementa x di 1. Infine, si assegnano i risultati della valutazione dell’espressione (10) a x tramite l’istruzione di assegnazione.

Forse un codice equivalente renderebbe chiara la situazione:

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

Questo è l’equivalente del tuo codice x = x++ in C #.

Il comportamento di x ++ è incrementare x ma restituire il valore prima dell’incremento. È chiamato incremento post per questo motivo.

Quindi x = x ++; semplicemente metti la volontà

1. restituire il valore , quindi

2. incrementare x , quindi

3. assegnare il valore originale (restituito nel passaggio 1) di x a x .

x = ++ x

equivale a 11.

 x++; 

fa quanto segue:

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

Come puoi vedere, il valore originale viene salvato, x viene incrementato e quindi viene restituito il valore originale.

Ciò che sta facendo è salvare il valore 10 da qualche parte, impostando x uguale a 11, e quindi restituendo 10, il che fa sì che x sia ripristinato a 10. Si noti che x in realtà diventa 11 per alcuni cicli (supponendo che non vi sia ottimizzazione del compilatore) .

Questo non risponde direttamente alla domanda, ma perché nel mondo qualcuno dovrebbe usarlo

 x = x++; 

?

Sconfigge totalmente lo scopo dell’operatore post-incremento / pre-incremento.

Puoi pensare in questo modo:

 int x = 10; 

X è un contenitore e contiene un valore, 10.

 x = x++; 

Questo può essere suddiviso in:

 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 

Ora, stampa il valore contenuto in x

 Console.WriteLine(x); 

E, non sorprende, stampa 10.

Per definizione, x ++, restituisce il valore di x e quindi incrementa x.

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

La prima cosa che fai è chiamata “post-incremento” che significa che

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

quindi nel momento in cui assegni x = x ++; x è ancora 10 quello che potresti fare, se hai bisogno di x per essere 11 in questa riga scrivi ++ x (pensa che sia chiamato pre incremento correggimi se sbaglio) … alternativamente right x ++; e che x = x ++;

domanda, è dipendente dalla linea o dalla dichiarazione che significa che aumenterà dopo il; ?

Prova a chiamare ++ x e vedi se funziona.

Mettere l’operatore di incremento dopo la variabile significa che l’incremento e l’assegnazione avviene dopo che l’espressione è stata valutata … quindi L’istruzione originale x = x ++; si traduce in 1. Valuta x e memorizza il valore nella memoria tirannia … Ora esegui il codice richiamato dall’operatore ++ …. (passaggi 2 e 3) 2. Valore incrementale di x (nella memoria temporanea) 3. Assegna valore incrementale alla posizione di archiviazione di x … Ora, continua con il resto dell’esecuzione della linea, a sinistra, c’è un segno = … 5. Quindi assegna il valore memorizzato nel passaggio 1 (valore non incrementato) all’espressione a sinistra di = segno .. . che è x

Forse non ho ragione, ma è più facile per me capire il risultato su un esempio simile:

 public static void main(String[] 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 } 

Diamo un’occhiata all’operazione y = x + x ++ passo dopo passo:

  1. Un computer prende il valore di x e lo aggiunge al valore di x (10 + 10 = 20)
  2. Il computer METTE IL RISULTATO AD UNA VARIABILE TEMPORANEA (temp = 20)
  3. La fotocopiatrice incrementa x (10 + 1 = 11)
  4. Il computer ASSEGNA LA RUSCIGLIA DELL’OPERAZIONE DEL LATO DESTRO MEMORIZZATO IN temp a variabile y (20)
  5. Un computer prende il valore di x e lo aggiunge al valore di x (11 + 11 = 22)
  6. Il risultato finale è: x = 22; y = 20

E ora torniamo al nostro esempio e facciamo gli stessi passi:

 public static void main(String[] args) { int x = 10; x = x++; //1, 2, 3, 4 System.out.println(x); //5 } 
  1. Un computer prende il valore di x (10)
  2. Il computer METTE IL RISULTATO AD UNA VARIABILE TEMPORANEA (temp = 10)
  3. La fotocopiatrice incrementa x (10 + 1 = 11)
  4. Il computer ASSEGNA LA RUSCIGLIA DELL’OPERAZIONE DEL LATO DESTRO MEMORIZZATO IN temp a variabile x (10)
  5. Il risultato finale è: x = 10

So che ci sono un sacco di risposte, e una accettata, ma metterò ancora i miei due centesimi per un altro punto di vista.

So che questa domanda era C #, ma presumo che per qualcosa come un operatore postfisso non abbia un comportamento diverso da C:

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

L'assembly (sì, l'ho modificato per renderlo più leggibile) generato dagli spettacoli del compilatore

 ... 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: ... 

Equivalentemente, il ciclo sta facendo qualcosa come:

 t = x x = x + 1 x = t 

Nota a margine: l'triggerszione delle ottimizzazioni offre alcuni risultati di assemblaggio come questo:

 ... L1: jmp L1 ... 

non si preoccupa nemmeno di memorizzare il valore che gli hai detto di dare x!

Come una dichiarazione autonoma, x++; è sia un incremento che un compito. Sembra che ci siano delle confusioni su cosa succede quando. Se abbiamo

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

Otterremo x = 11 y = 12 . Viene assegnato il valore corrente di x, quindi viene eseguito l’incremento e la riassegnazione di x. Quindi, quando si utilizza la stessa variabile,

 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) 

In qualsiasi modo tu lo guardi, il nuovo valore di x è 11.

Ho sbagliato completamente su quello.

Spiegazione semplice:

x ++ è un’incrementazione postfissa.

Cosa fa il compilatore:

a) Assegna il valore di x a x b) Aumenta un valore temporaneo di x (suppongo che possa essere anche ottimizzato) c) Getta via il valore temporaneo di x

Se vuoi che il codice restituisca 11 con il compito, scrivi:

x = ++ x;

Il risultato del compito

 x = x++; 

non è definito in C e C ++ e indubbiamente lo stesso con C #.

Quindi, la sequenza effettiva delle operazioni che si verifica dipende da come il compilatore decide di implementarla, non c’è alcuna garanzia che l’assegnazione o l’incremento si verifichi prima. (questo è ben definito in C #, come ha sottolineato Jon Skeet nei commenti, anche se ora sento che questa risposta ha un valore molto minore ora, sto mantenendo questo post non cancellato per la domanda dell’OP e la sua risposta nei commenti.)

Tuttavia, in questo caso, sembra che la sequenza di operazioni che avviene sia:

  1. il vecchio valore (10) di x viene salvato
  2. x è incrementato per la parte ++
  3. il vecchio valore ora è assegnato a x per l’assegnazione

In questo modo, sebbene l’incremento si verifichi, viene superato dall’assegnazione con il vecchio valore, mantenendo così x a 10.

HTH