01/07/12 14:56
a_butta
Postato originariamente da nessuno:
Corretto ... scrivere
a=a++;
è come scrivere
a = a;
Corretto ... scrivere
a=a++;
è come scrivere
a = a;
Ma... se ho capito bene il post-incremento dovrebbe eseguire prima l'operazione precedente, e poi incrementare la variabile interessata.
Quando allora si scrive
x = x++;
dovrebbe prima assegnare
x = x
e poi incrementare
x = x + 1
La mia domanda: cosa incrementa? Cioè nella prima espressione, la x a destra + "diversa" dalla x a sinistra? Il compilatore che fa esattamente?
aaa
01/07/12 15:20
In effetti, sarà il caldo e la cpu è andata ... :-) ... ma bisogna fare chiarezza ...
In C++ (che penso sia quello a cui molti fanno riferimento), in effetti avviene che
a=a++;
mov eax,dword ptr [a]
mov dword ptr [a],eax
mov ecx,dword ptr [a]
add ecx,1
mov dword ptr [a],ecx
è equivalente a
a=a; (prime due istruzioni)
a++; (ultime tre istruazioni)
mentre nel caso
a=++a;
mov eax,dword ptr [a]
add eax,1
mov dword ptr [a],eax
mov ecx,dword ptr [a]
mov dword ptr [a],ecx
è equivalente a
a++; (ultime tre istruazioni)
a=a; (prime due istruzioni)
[/b]In definitiva, in tutti e due i casi avremo che la variabile aumenta di valore[/b]
Ma in C# (e suppongo anche in Java, anche se non ho controllato) avviene che
a=a++;
IL_0003: ldloc.0
IL_0004: dup
IL_0005: ldc.i4.1
IL_0006: add
IL_0007: stloc.0
IL_0008: stloc.0
è semplicemente equivalente a
a=a;
e invece
a=++a;
IL_0003: ldloc.0
IL_0004: ldc.i4.1
IL_0005: add
IL_0006: dup
IL_0007: stloc.0
IL_0008: stloc.0
equivale ad
a++;
In C++ (che penso sia quello a cui molti fanno riferimento), in effetti avviene che
a=a++;
mov eax,dword ptr [a]
mov dword ptr [a],eax
mov ecx,dword ptr [a]
add ecx,1
mov dword ptr [a],ecx
è equivalente a
a=a; (prime due istruzioni)
a++; (ultime tre istruazioni)
mentre nel caso
a=++a;
mov eax,dword ptr [a]
add eax,1
mov dword ptr [a],eax
mov ecx,dword ptr [a]
mov dword ptr [a],ecx
è equivalente a
a++; (ultime tre istruazioni)
a=a; (prime due istruzioni)
[/b]In definitiva, in tutti e due i casi avremo che la variabile aumenta di valore[/b]
Ma in C# (e suppongo anche in Java, anche se non ho controllato) avviene che
a=a++;
IL_0003: ldloc.0
IL_0004: dup
IL_0005: ldc.i4.1
IL_0006: add
IL_0007: stloc.0
IL_0008: stloc.0
è semplicemente equivalente a
a=a;
e invece
a=++a;
IL_0003: ldloc.0
IL_0004: ldc.i4.1
IL_0005: add
IL_0006: dup
IL_0007: stloc.0
IL_0008: stloc.0
equivale ad
a++;
Ultima modifica effettuata da 01/07/12 15:33
01/07/12 15:47
Premoli
Postato originariamente da nessuno:
In effetti, sarà il caldo e la cpu è andata ... :-) ... ma bisogna fare chiarezza ...
In C++ (che penso sia quello a cui molti fanno riferimento), in effetti avviene che
a=a++;
mov eax,dword ptr [a]
mov dword ptr [a],eax
mov ecx,dword ptr [a]
add ecx,1
mov dword ptr [a],ecx
è equivalente a
a=a; (prime due istruzioni)
a++; (ultime tre istruazioni)
mentre nel caso
a=++a;
mov eax,dword ptr [a]
add eax,1
mov dword ptr [a],eax
mov ecx,dword ptr [a]
mov dword ptr [a],ecx
è equivalente a
a++; (ultime tre istruazioni)
a=a; (prime due istruzioni)
[/b]In definitiva, in tutti e due i casi avremo che la variabile aumenta di valore[/b]
Ma in C# (e suppongo anche in Java, anche se non ho controllato) avviene che
a=a++;
IL_0003: ldloc.0
IL_0004: dup
IL_0005: ldc.i4.1
IL_0006: add
IL_0007: stloc.0
IL_0008: stloc.0
è semplicemente equivalente a
a=a;
e invece
a=++a;
IL_0003: ldloc.0
IL_0004: ldc.i4.1
IL_0005: add
IL_0006: dup
IL_0007: stloc.0
IL_0008: stloc.0
equivale ad
a++;
In effetti, sarà il caldo e la cpu è andata ... :-) ... ma bisogna fare chiarezza ...
In C++ (che penso sia quello a cui molti fanno riferimento), in effetti avviene che
a=a++;
mov eax,dword ptr [a]
mov dword ptr [a],eax
mov ecx,dword ptr [a]
add ecx,1
mov dword ptr [a],ecx
è equivalente a
a=a; (prime due istruzioni)
a++; (ultime tre istruazioni)
mentre nel caso
a=++a;
mov eax,dword ptr [a]
add eax,1
mov dword ptr [a],eax
mov ecx,dword ptr [a]
mov dword ptr [a],ecx
è equivalente a
a++; (ultime tre istruazioni)
a=a; (prime due istruzioni)
[/b]In definitiva, in tutti e due i casi avremo che la variabile aumenta di valore[/b]
Ma in C# (e suppongo anche in Java, anche se non ho controllato) avviene che
a=a++;
IL_0003: ldloc.0
IL_0004: dup
IL_0005: ldc.i4.1
IL_0006: add
IL_0007: stloc.0
IL_0008: stloc.0
è semplicemente equivalente a
a=a;
e invece
a=++a;
IL_0003: ldloc.0
IL_0004: ldc.i4.1
IL_0005: add
IL_0006: dup
IL_0007: stloc.0
IL_0008: stloc.0
equivale ad
a++;
Esattamente... infatti se rileggi il mio post ho specificato, in java, del resto siamo nella sezione java...
aaa