Newsgroup: it.comp.lang.c++
Titolo: NIUBBI WARNING: ++i vs i++

Volevo sapere perchè la gente "fica" evita i++ come la peste usando ++i
appena può.
Quanto si guadagna così? Vale la pena cambiare tutte le mie abitudini e
tutti i miei cicli for e tutto il resto per questa finezza (i.e. vale la
pena che mi metta alla lavagna a scrivere 100 volte "i++ è brutto, meglio
++i", "i++ è brutto, meglio ++i","i++ è brutto, meglio ++i" come Bart
Simpson?).
Grazie
--
Emanuele Di Saverio
---------------------------------------------
Remove NOSPAM manually for reply
Scusate le vaccate se  ne dico!

 appena può.
Perchè non ha un compilatore che ottimizza automaticamente... ?
;)
-- 
Luc.

 Volevo sapere perchè la gente "fica" evita i++ come la peste usando ++i
Non è questione di essere "fichi" come dici tu ! Quelle che scrivi sono due
operazioni diverse: Preincremento e postincremento.
Il preincremento può servire se c'è necessità di incrementare una variabile
prima e poi utilizzarla e/o modificarla...
i.e.
i=4;
A[++i]=k ;
In questo caso la var i viene incrementata prima dell'assegnamento e  viene
assegnato k alla cella A[5] ,
Se invece fosse
i=4;
A[i++]=k;
Viene prima fatto l'assegnamento di k alla cella A[4], dopodichè viene
incrementata i di 1 ( i =5) ;
ciao

 Non è questione di essere "fichi" come dici tu !
Si parlava del terzo parametro nei cicli for....
-- 
Luc.

 Si parlava del terzo parametro nei cicli for....
Se rileggi attentamente il post iniziale , ti accorgi che non era solo del
for che l'OP parlava.... ma solo della differenza tra le due forme.
ciao

 Grazie
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

Si parlava del terzo parametro nei cicli for....
Si parlava delle sue "abitudini".
I cicli for, come terzo parametro, potrebbero benissimo non avere
alcun incremento.

Quanto si guadagna così?
Nulla.  A livello prestazionale e` la stessa cosa.

 Simpson?).
Generalmente è meglio usare il preincremento, dove possibile. Se stai
utilizzando un int o comunque un tipo predefinito del c++ magari il
compilatore ottimizza il tutto e non hai nessuna penalità (leggi: non ci
guadagni nulla a usare il preincremento). Se stai utilizzando invece
l'operatore di post-incremento su un UDT dove magari la copia di un
oggetto è costosa in termini computazionali la differenza si fa sentire e
devi stare attento a quale delle due forme scegliere. 


Simone Finotti wrote:
scusate, ho un bug nel dito indice destro che mi fa clickare in maniera
compulsoria e involontaria sui tasti 'Invia'..


 Simpson?).
Perche', mentre il preincremento ( ++i ) si limita a manipolare il
proprio argomento e a restituirlo per reference, il postincremento deve
anche salvare lo stato iniziale per poterlo restituire. Questo valore
non puo' che essere salvato in una variabile temporanea che dovra'
essere copiata ulteriormente al ritorno dalla chiamata; questa copia e'
teoricamente ottimizzabile, ma non e' detto che i compilatori lo
facciano davvero.
Per i tipi interi questa operazione e' trascurabile, mentre per i tipi
definiti dall'utente questo a priori non e' detto.
In particolare per gli iteratori non conviene dare per scontato che le
due operazioni siano equivalenti in termini di prestazioni. Tanto vale
quindi abituarsi ad usare il postincremento solo ed esclusivamente
quando si ha necessita' di utilizzare il valore ritornato.
Ciao,
Nicola
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

due operazioni siano equivalenti in termini di prestazioni. 
..acc... scusate, pensavo fossimo in it.comp.lang.c


GRAZIE ora mi è tutto chiaro....vado alla lavagna...



EH? ma come Simone mi aveva detto diversamente!


EH? ma come Simone mi aveva detto diversamente!
Infatti Simone ha considerato anche i tipi UDT, che io (erroneamente)
non ho considerato.  Nel caso di tipi UDT e` possibile che il
preincremento sia piu` performante.  In ogni caso, per tipi "built-in"
come gli interi, non c'e` alcun vantaggio prestazionale.

 Si parlava del terzo parametro nei cicli for....
pensa se i fosse di un tipo in cui ++i (senza temporaneo) ha tempo 
atomico, mentre la creazione di un nuovo oggetto temporaneo da parte i++ 
richiede un fottio di tempo, e anche la sua distruzione. nessun 
compilatore ottimizzera' via il postincremento in un caso del genere
esempio equivalente
while (lista_files) {
  std::ifstream input(lista_files.top());
  traduci_in_francese(input);
}
confrontato con 
std::ifstream input;
while (lista_files) {
  input.open(lista_files.top());
  traduci_in_francese(input);
  input.close();
}
nessun compilatore riuscira' a tradurre dalla prima alla seconda versione