Printable View
Stavo leggendo un interessante post su come viene risolto il comando
in C#.Codice:a = 3
a += a++
Incuriosito ho provato anche su PHP scoprendo un comportamento differente ..ed in un caso preoccupante.
Quanto fa?
Ed ora provate...Codice:$a += $a++
(con $a = 3 o altro numero)Codice:$a += ++$a
Ma soprattuto perchè?
Il motivo è da ricercare nel compilatore ... stasera finisco il post con la soluzione.
...forse,
A me viene 7 come primo risultato e 8 come secondo.
Non mi pare tanto strano...
ciao!
Il secondo dovrebbe dare 7
Perchè?
Prima aumenta $a di uno, quindi 4
Poi assegna ad $a il doppio del suo valore attuale, cioè 4
= 8
Ciao!
Il problema è che
a += ++a
equivale a
a = a + ++a
l'incremento di a dovrebbe avvenire solo alla fine.
a = 3 + 4
altrimenti ++davanti non ha senso
cioè
a = 3
++a + a = 8 (4 + 4)
a + ++a = 7 (3 + 4)
Eh no, come dici tu non avrebbe senso lo spostamento dei ++
Ci dev'essere la differenza, no?
E' una questione di precedenze.
Ciao!
appunto.
se a = 3 ad esempio
a + ++a + a = 3 + 4 + 4
mentre
a + a++ + a = 3 + 4 + 3
Dipende dall'ordine, ma php non sembra prende in considerazione l'ordine.
Premetto che non conosco i dettagli de c#, ma in php l'operatore ++ ha una precedenza più alta di += e compagnia.
Le espressioni vengono quindi lette come:
$a += $a++ :arrow: = ( + ( $a, postfix-increment($a) ) )
$a += ++$a :arrow: = ( + ( $a, prefix-increment($a) ) )
e poi valutate a partire dai nodi più interni (le foglie dell'albero di parsing)
prendi il valore di $a, poi incrementalo, somma il valore iniziale ad $a, assegna il valore ad $a = 3 + (3+1) = 7
incrementa $a e prendine il valore, sommalo ad $a, assegna il valore ad $a = 3+1 + 4 = 8
Il secondo può dare 7 solo se cambi la definizione del linguaggio, o se usi un linguaggio con una diversa definizione. La differenza in questo caso la fa la lazy evaluation: quando vedi una variabile in una espressione, la traduci subito nel suo valore, oppure aspetti fino all'ultimo, quindi ti serve proprio il valore?
Il c#, a quando capisco da quello che dici, non usa la lazy evaluation, oppure valuta l'albero delle espressioni dalla radice, "richiedendo" ai diversi rami di fornire un risultato.
edit:
no, questo è sbagliato.Citazione:
se a = 3 ad esempio
a + ++a + a = 3 + 4 + 4
mentre
a + a++ + a = 3 + 4 + 3
a + ++a + a = 3 + 4 + 4
ma
a + a++ + a = 3 + 3 + 4
l'incremento avviene subito dopo aver preso il valore di a, non dopo aver valutato l'intera espressione
Si è vero, ho fatto vari test, si comporta come c++ in modo invertito.
Ossia.
con x = 1
c#
x+= x++ + ++x;
restituisce 5 e procede la trasforma in questo modo
x = x + x++ + ++x
x = 1 + 1(+1) + 2+1
x = 1 + 1 + 3
c++ e php
x += x++ + 2
x += 2(+1) + 2
x = x + 2(+1) + 2 -> x = (2+1)
x = 3 + 2 + 2
x = 7
Dovrebbe essere questo il comportamento
CHIARAMENTE preferisco il comportamento del compilatore di C#.
Sarebbe interessante provare la stessa cosa su MONO per vedere cosa restituisce.
Nel linguaggio C l'ho sempre vista così:
- se il simbolo ++ si trova dopo una variabile, questa variabile viene incrementata dopo l'esecuzione dell'istruzione che la contiene
- se il simbolo ++ si trova prima della variabile, questa variabile viene incrementata prima dell'esecuzione dell'istruzione che la contiene
Da ciò consegue che:
- a = 3; a += a++ => a = 7 (prima aggiungo a = 3 ad a = 3, ottenendo a = 6, poi incremento di 1, quindi a = 7)
- a = 3; a += ++a => a = 8 (prima incremento di 1, cioè a = 4, poi aggiungo a = 4, ottenendo a = 8)
Statemi bene...
La differenza tra ++ prima o dopo la so, non mi era chiaro perchè eseguisse prima la ++ e non la += ma come scritto sopra da dreadnaut ha la precedenza al contrario di c#.
E cmq mi chiedo perchè ++ abbia priorità.
Ma come scritto nel post che ha fatto nascere il tutto
http://blogs.msdn.com/lucabol/archiv...31/223580.aspx
Does it matter which of the previous options is the correct one? Not really because…
YOU ARE NOT GOING TO WRITE THAT CODE J
Gli operatori ++ e += hanno la stessa relazione di precedenza anche in C#, quindi la differenza dev'essere un'altra.
E quello che ha scritto sopra dementialsite è incorretto: non si tratta di esecuzione prima o dopo dell'istruzione, ma prima o dopo la valutazione della variabile. La differenza è quella fra "prendo il valore, poi come side-effect aumento la variabile" e "incremento la variabile, e poi ne prendo il valore", ma questo viene fatto durante l'istruzione (da non confondersi con l'espressione.
Leggi il link del mio post precedente
and knowing that c# evaluates expressions left to right
...è Lead Program Manager alla microsoft, penso sappia ciò che dice.
++a e a++
se faccio un echo dovrei avere valori differenti dato che
viene restituito il valore incrementato nel primo caso
nel secondo viene restituita la variabile e poi incrementata.
Ho letto adesso quello che aveva scrito, si la descrizione non è corretta, non è una "sostituzione".
E infatti è così.Citazione:
Originalmente inviato da binarysun
ciao!
LA seconda parte era la risposta per la #10, ma poi ho subito rileto quello scritto ed ho modificato il post.
La prima parte era riferita a
Citazione:
Gli operatori ++ e += hanno la stessa relazione di precedenza anche in C#, quindi la differenza dev'essere un'altra.
Sarebbe bello. Afferma anche che "By the way, in c++ the behavior for this expression is undefined…" quando in realtà lo è. Ma saranno questioni di interpretazione.Citazione:
Originalmente inviato da binarysun
edit: geniale però il modo in cui ti butta li tre risposte alla fine, e non ti dice quale sia vera - qualcuno potrebbe usare un codice simile a quello, e voler sapere perché le cose funzionano diversamente, se è stato un errore o no.
Comunque anche php e c/c++ sono left associative, quindi la differenza non è quella.
Sono tutte vere, sono tre esempi ed è il risultato che da c#, semplciemente alla fine dice "qual'è il comportamento correto? non è importante dato che è codice da non usare"
Ma quindi se mi dici che anche c++ è left associative ...come azzo funziona?
un dato di fatto (ho provato) è che con
x=1;
x+= x++ + ++x;
c# restituisce 5
c++ restituisce 7
Dando per scontato che i sistema di Pre-increment e post-increment funzioni in modo identico l'unica differenza è l'ordine.
in c# la funzione sopra scritta:
x = x+ x++ + ++x; .. = 5
x = x++ + ++x + x; ... = 7
in c++
x = x+ x++ + ++x; .. = 7
x = x++ + ++x + x; ... = 7
per c++ ho usato visual studio c++
effettivamente c'è qualcosa di strano, ma il problema risiede solamente nell'operatore +=
analizzate questo:
x=1;
x+= (x=10);
In C++ alla fine x==20
in C# (mono) alla fine x==11
in C# se il valore X durante la valutazione dell'espressione cambia, non viene aggiornato per l'operazione di assegnamento composto
non saprei stabilire quale dei due sia più corretto, certamente il comportamento in C++ deriva da linguaggi che ormai hanno fatto la storia e una larga maggioranza di programmatori dovrebbe aspettarsi questo in qualsiasi linguaggio
È strano però che tale differenza non l'abbia mai letta su nessun testo che spiega C# confrontandolo con C++ e Java
Edit: In Java alla fine x==11
Quindi sembrerebbe che i linguaggi, compilati, che girano in una VM si comportino diversamente
e x = x + (x = 10); cosa ti restuisce? In teoria (e spero anche in pratica) dovrebbe essere lo stesso.
Mi piacerebbe trovare una spiegazione completa di questa cosa - gli esempi purtroppo sono compatibili con più di una spiegazione, fra cui un diverso ordine di visita dell'albero e late/early binding, ma non si capisce :|
Trovato! http://en.wikipedia.org/wiki/Augmented_assignment
È un problema di ottimizzazione, che consiste nel non aggiornare la variabile
Ecco perchè il comportamento in C#/Java mi sapeva tanto di assembler....
Comunque questa cosa crea non poca confusione e potrebbe esser la madre di un sacco di bug :mrgreen:
uhm, non c'è però ancora una spiegazione delle differenze, o sbaglio?
Ho provato in c++ comunque, e le espressioni x += ... danno lo stesso risultato di quelle x = x + ...
già.... su wikipedia ci si limita a una descrizione formale dell'operazione, che però è la base da cui partire per ragionare su questo comportamento.
Sul K&R l'assegnamento composto viene descritto nello stesso modo in cui viene enunciato in C# e imagino che nulla cambi anche per altri linguaggi
Secondo me una possibile causa è da ricercare nel modo in cui sono viste le variabili nei linguaggi Java e C# che, come ben sappiamo, sono considerati oggetti e non tipi primitivi
Lo penso anche io, l'operatore ++ fa parte della struttura/classe integer.Citazione:
Originalmente inviato da AlexKidd