Che cos'è x dopo “x = x ++”?

Cosa succede (dietro le tende) quando questo viene eseguito?

int x = 7;
x = x++;

Cioè, quando una variabile viene post incrementata e assegnata a se stessa in un'istruzione? Ho compilato ed eseguito questo. xè ancora 7 anche dopo l'intera affermazione . Nel mio libro, dice che xè aumentato!

xviene incrementato. Ma stai assegnando il vecchio valore del xritorno a se stesso.

x = x++;

1. x++incrementa xe restituisce il suo vecchio valore.
2. x = assegna il vecchio valore a se stesso.

Quindi, alla fine, xviene assegnato al suo valore iniziale.

x = x++;

è equivalente a

int tmp = x;
x++;
x = tmp;

La dichiarazione:

x = x++;

è equivalente a:

tmp = x;   // ... this is capturing the value of "x++"
x = x + 1; // ... this is the effect of the increment operation in "x++" which
           //     happens after the value is captured.
x = tmp;   // ... this is the effect of assignment operation which is
           //     (unfortunately) clobbering the incremented value.

In breve, l'affermazione non ha alcun effetto.

I punti chiave:

• Il valore di un'espressione di incremento / decremento Postfix è il valore dell'operando prima che abbia luogo l'incremento / decremento. (Nel caso di un modulo Prefisso, il valore è il valore dell'operando dopo l'operazione,)

• l'RHS di un'espressione di assegnazione viene completamente valutata (inclusi eventuali incrementi, decrementi e / o altri effetti collaterali) prima che il valore venga assegnato all'LHS.

_{Si noti che, diversamente da C e C ++, l'ordine di valutazione di un'espressione in Java è totalmente specificato e non c'è spazio per variazioni specifiche della piattaforma. I compilatori sono autorizzati a riordinare le operazioni solo se ciò non modifica il risultato dell'esecuzione del codice dalla prospettiva del thread corrente. In questo caso, un compilatore sarebbe autorizzato a ottimizzare l'intera istruzione perché si può dimostrare che è una no-op.}

Nel caso in cui non sia già ovvio:

• "x = x ++;" è quasi certamente un errore in qualsiasi programma.
• L'OP (per la domanda originale!) Probabilmente significava "x ++;" anziché "x = x ++;".
• Le istruzioni che combinano incremento / decremento automatico e assegnazione sulla stessa variabile sono difficili da comprendere, e quindi dovrebbero essere evitate indipendentemente dalla loro correttezza . Semplicemente non è necessario scrivere codice del genere.

Si spera che controllori di codice come FindBugs e PMD contrassegnino il codice come questo come sospetto.

int x = 7;
x = x++;

Ha un comportamento indefinito in C e per Java vedere questa risposta . Dipende dal compilatore cosa succede.

Un costrutto come x = x++;indica che probabilmente stai fraintendendo ciò che l' ++operatore fa:

// original code
int x = 7;
x = x++;

Riscriviamo questo per fare la stessa cosa, in base alla rimozione ++dell'operatore:

// behaves the same as the original code
int x = 7;
int tmp = x; // value of tmp here is 7
x = x + 1; // x temporarily equals 8 (this is the evaluation of ++)
x = tmp; // oops! we overwrote y with 7

Ora, riscriviamolo per fare (quello che penso) che volevi:

// original code
int x = 7;
x++;

La sottigliezza qui è che l' ++operatore modifica la variabilex , a differenza di un'espressione come x + x, che valuterebbe un valore int ma lascerebbe xinvariata la variabile stessa. Considera un costrutto come il venerabile forloop:

for(int i = 0; i < 10; i++)
{
    System.out.println(i);
}

Notate il i++dentro? È lo stesso operatore. Potremmo riscrivere questo forciclo in questo modo e si comporterebbe lo stesso:

for(int i = 0; i < 10; i = i + 1)
{
    System.out.println(i);
}

Consiglio anche di non utilizzare l' ++operatore in espressioni più grandi nella maggior parte dei casi. A causa della sottigliezza di quando modifica la variabile originale in pre-post-incremento ( ++xe x++, rispettivamente), è molto facile introdurre bug sottili che sono difficili da rintracciare.

Secondo il codice byte ottenuto dai file di classe,

Entrambe le assegnazioni incrementano x, ma la differenza è la tempistica di when the value is pushed onto the stack

In Case1, Push si verifica (e quindi in seguito assegnato) prima dell'incremento (essenzialmente significa che l'incremento non fa nulla)

In Case2, l'incremento si verifica prima (rendendolo 8) e quindi viene inserito nello stack (e quindi assegnato a x)

Caso 1:

int x=7;
x=x++;

Codice byte:

0  bipush 7     //Push 7 onto  stack
2  istore_1 [x] //Pop  7 and store in x
3  iload_1  [x] //Push 7 onto stack
4  iinc 1 1 [x] //Increment x by 1 (x=8)
7  istore_1 [x] //Pop 7 and store in x
8  return       //x now has 7

Caso 2:

int x=7; 
x=++x;

Codice byte

0  bipush 7     //Push 7 onto stack
2  istore_1 [x] //Pop 7 and store in x
3  iinc 1 1 [x] //Increment x by 1 (x=8)
6  iload_1  [x] //Push x onto stack
7  istore_1 [x] //Pop 8 and store in x
8  return       //x now has 8

• Stack qui si riferisce a Stack di operando, locale: x indice: 1 tipo: int

Viene incrementato dopo " x = x++;". Sarebbe 8 se lo facessi " x = ++x;".

L'operatore Post Increment funziona come segue:

1. Memorizza il valore precedente dell'operando.
2. Incrementa il valore dell'operando.
3. Restituisce il valore precedente dell'operando.

Quindi la dichiarazione

int x = 7;
x = x++; 

sarebbe valutato come segue:

1. x è inizializzato con valore 7
2. l'operatore post increment memorizza il valore precedente di x ie 7 per restituirlo.
3. Incrementa la x, quindi ora x è 8
4. Restituisce il valore precedente di x ie 7 e viene assegnato di nuovo a x, quindi x diventa di nuovo 7

Quindi x è effettivamente aumentato, ma poiché x ++ sta assegnando il risultato a x, il valore di x viene sovrascritto al valore precedente.

L'incremento si verifica dopo la chiamata di x, quindi x è uguale a 7. ++ x sarebbe uguale a 8 quando viene chiamata x

Quando riassegni il valore per xè ancora 7. Prova x = ++xe otterrai 8 altro

x++; // don't re-assign, just increment
System.out.println(x); // prints 8

perché x ++ incrementa il valore DOPO averlo assegnato alla variabile. così via e durante l'esecuzione di questa linea:

x++;

varialbe x avrà ancora il valore originale (7), ma usando di nuovo x su un'altra riga, come

System.out.println(x + "");

ti darà 8.

se si desidera utilizzare un valore incrementato di x sull'istruzione di assegnazione, utilizzare

++x;

Questo aumenterà x di 1, POI assegna quel valore alla variabile x.

[Modifica] invece di x = x ++, è solo x ++; il primo assegna il valore originale di x a se stesso, quindi in realtà non fa nulla su quella linea.

Cosa succede quando int x = 7; x = x++;?

ans -> x++significa prima utilizzare il valore di x per l'espressione e quindi aumentarlo di 1.
Questo è ciò che accade nel tuo caso. Il valore di x su RHS viene copiato nella variabile x su LHS e quindi il valore di xviene aumentato di 1.

Allo stesso modo ++x significa ->aumentare il valore di x prima di uno e quindi utilizzare in espressione.
Quindi, nel tuo caso, se lo fai x = ++x ; // where x = 7
otterrai un valore di 8.

Per maggiore chiarezza, prova a scoprire quante istruzioni printf eseguiranno il seguente codice

while(i++ <5)   
  printf("%d" , ++i);   // This might clear your concept upto  great extend

++xè pre-incremento ->x viene incrementato prima dell'uso
x++è post-incremento ->x viene incrementato dopo l'uso

int x = 7; -> x get 7 value <br>
x = x++; -> x get x value AND only then x is incremented

Quindi questo significa: x++non è uguale ax = x+1

perché:

int x = 7; x = x++;
x is 7

int x = 7; x = x = x+1;
x is 8

e ora sembra un po 'strano:

int x = 7; x = x+=1;
x is 8

molto dipendente dal compilatore!

x = x ++;

Questo è l'operatore post-incremento. Dovrebbe essere inteso come "Usa il valore dell'operando e quindi incrementa l'operando".

Se si desidera che avvenga il contrario, ovvero "Incrementa l'operando e quindi utilizza il valore dell'operando", è necessario utilizzare l'operatore di pre-incremento come mostrato di seguito.

x = ++ x;

Questo operatore prima incrementa il valore di x di 1 e quindi assegna il valore a x.

Penso che questa controversia possa essere risolta senza entrare nel codice e pensare.

Considera i ++ e ++ i come funzioni, ad esempio Func1 e Func2.

Ora i = 7;
Func1 (i ++) restituisce 7, Func2 (++ i) restituisce 8 (lo sanno tutti). Internamente entrambe le funzioni incrementano da i a 8, ma restituiscono valori diversi.

Quindi i = i ++ chiama la funzione Func1. All'interno della funzione i aumenta a 8, ma al termine la funzione restituisce 7.

Quindi alla fine 7 viene assegnato a i. (Quindi alla fine, i = 7)

Questo perché hai usato un operatore post-incremento. In questa seguente riga di codice

x = x++;

Quello che succede è che stai assegnando il valore di x a x. x ++ incrementa x dopo che il valore di x è assegnato a x. Ecco come funzionano gli operatori post-incremento. Funzionano dopo che è stata eseguita una dichiarazione. Quindi nel tuo codice, x viene restituito prima dopo, quindi viene incrementato.

Se avete fatto

x = ++x;

La risposta sarebbe 8 perché hai usato l'operatore di pre-incremento. Ciò incrementa il valore prima di restituire il valore di x.