Problema tempistica incremento

[Lancill]

Salve a tutti, ad un'occhiata veloce, il seguente pezzo di codice dovrebbe dare in output 1... invece da 0.

public class ProblemaIncremento {   	
      public static void main(String[] args) { 

 		int i=0; 		
                i = i++; 		
                System.out.println(i);  	
       }  
}

La mia ipotesi è che l'incremento utilizzi una variabile temporanea che non si trova aggiornata in tempo per l'assegnazione ad i... ma non ne ho la certezza!
Qualcuno di voi mi riesce a spiegare perchè succede questa cosa?

Grazie in anticipo

[andbin]

Originariamente inviato da Lancill
Salve a tutti, ad un'occhiata veloce, il seguente pezzo di codice dovrebbe dare in output 1... invece da 0.

Qualcuno di voi mi riesce a spiegare perchè succede questa cosa?

Il post-incremento si "perde". La prima cosa che fa è valutare la espressione. La espressione i++, essendo un post-incremento (quindi fatto dopo) porta a valutare subito i che vale 0. Viene quindi eseguito il post-incremento. E infine la assegnazione. Ma la assegnazione viene fatta con il valore che è stato "valutato" all'inizio!!! Quindi viene assegnato 0.

Se ci fosse:

int i = 0;
i = i++ + i++;

Stampi 1. È vero che ci sono 2 post-incrementi ma l'ultimo si perde. Anche qui prima valuta gli operandi: il primo operando i++ viene valutato 0, poi viene fatto il post-incremento. In questo frangente i vale 1. Il secondo operando i++ viene valutato 1, poi viene fatto il post-incremento tale per cui i diventa 2.
Ma poi viene fatta la somma e i valori sommati sono quelli valutati all'inizio cioè 0 e 1. Risultato: 1.

[Lancill]

quindi mi confermi che in pratica l'operatore di postincremento utilizza una variabile temporanea in cui conserva il valore successivo di i?
Nel senso che nel momento che faccio i++ non incrementa direttamente la i, ma utilizza un'altra locazione di memoria per il valore successivo?

[andbin]

Originariamente inviato da Lancill
quindi mi confermi che in pratica l'operatore di postincremento utilizza una variabile temporanea in cui conserva il valore successivo di i?
Nel senso che nel momento che faccio i++ non incrementa direttamente la i, ma utilizza un'altra locazione di memoria per il valore successivo?

Certo che incrementa direttamente la variabile!!! Non c'è alcuna variabile "temporanea".

Nel caso con 2 post incrementi che ho fatto io, lo ripeto meglio:

a) Valuta il primo operando (vale 0)
b) Incrementa i (diventa 1)
c) Valuta il secondo operando (vale 1 ... i incrementato al punto b)
d) Incrementa i (diventa 2)
e) Esegue la somma di ciò che ha "valutato" (0+1)
f) Assegna il risultato della somma ad i, cioè 1.

[Lancill]

ok ok, ora è tutto chiaro! Grazie mille, mi mancava il tassello della valutazione che veniva fatta prima del postincremento!

Dankiu

[LeleFT]

Prova ad eseguire questa e ti accorgerai della differenza:

int a = 0;
int b = 0;

int c = a++;
int d = ++b;

System.out.println("C = " + c + "; D = " + d);

Ciao.

[Lancill]

Originariamente inviato da LeleFT
Prova ad eseguire questa e ti accorgerai della differenza:

int a = 0;
int b = 0;

int c = a++;
int d = ++b;

System.out.println("C = " + c + "; D = " + d);

Ciao.

ti ringrazio, ma nel tuo esempio non avrei avuto dubbi sul risultato!
L'operatore pre e post incremento non è così complicato, mi mancava solo la priorità sulla valutazione della stessa variabile!
In pratica mi aspettavo che

     int i=0; 	
     i = i++;
     System.out.println(i);

fosse così:

     int i=0; 	
     i = i; //assegno valore di i
     i = i+1; //incremento la i
     System.out.println(i); // stampa di 1

invece a quanto pare

     int i=0; 		
     i = i; 
     i+1;
     System.out.println(i); //e quindi stampo 0

giusto?

[andbin]

Originariamente inviato da Lancill
invece a quanto pare

     int i=0; 		
     i = i; 
     i+1;
     System.out.println(i); //e quindi stampo 0

giusto?

Non è proprio così ... il post incremento lo fa prima dell'assegnamento. Prima valuta (0), poi incrementa, poi assegna ad i ... ed è qui che si "perde" l'incremento!

[Lancill]

Originariamente inviato da andbin
Non è proprio così ... il post incremento lo fa prima dell'assegnamento. Prima valuta (0), poi incrementa, poi assegna ad i ... ed è qui che si "perde" l'incremento!

si il mio era un esempio di cosa accade concettualmente (se ho capito bene)...

Ora ti faccio una domanda per vedere se ho capito veramente!

Il problema è che la valutazione di i viene fatta prima dell'incremento e quindi quando vado ad assegnare, assegno il valore della valutazione senza "accorgermi" che il valore di i è stato incrementato. Giusto?

[andbin]

Originariamente inviato da Lancill
Il problema è che la valutazione di i viene fatta prima dell'incremento e quindi quando vado ad assegnare, assegno il valore della valutazione senza "accorgermi" che il valore di i è stato incrementato. Giusto?

Esatto!