++ i o i ++ in per cicli ??

Possibile duplicato:
Esiste una differenza di prestazioni tra i ++ e ++ i in C ++?

C’è una ragione per cui alcuni programmatori scrivono ++i in un normale ciclo di ricerca invece di scrivere i++ ?

Per gli interi, non vi è alcuna differenza tra pre e post-incremento.

Se i è un object di una class non banale, in genere, viene preferito ++i perché l’object viene modificato e quindi valutato, mentre i++ modifica dopo la valutazione, quindi richiede una copia.

++i è leggermente più efficiente grazie alla sua semantica:

 ++i; // Fetch i, increment it, and return it i++; // Fetch i, copy it, increment i, return copy 

Per gli indici int-like, il guadagno di efficienza è minimo (se presente). Per gli iteratori e altri oggetti più pesanti, evitare che la copia possa essere una vera vittoria (in particolare se il corpo del loop non contiene molto lavoro).

Ad esempio, considera il seguente ciclo utilizzando una class BigInteger teorica che fornisce numeri interi arbitrari di precisione (e quindi una sorta di interni di tipo vettoriale):

 std::vector vec; for (BigInteger i = 0; i < 99999999L; i++) { vec.push_back(i); } 

Quella operazione di i ++ include la costruzione della copia (cioè l'operatore nuovo, copia per cifra) e la distruzione (cancellazione dell'operatore) per un ciclo che non farà altro che fare essenzialmente un'altra copia dell'object indice. Essenzialmente hai raddoppiato il lavoro da fare (e probabilmente aumentando la frammentazione della memoria) semplicemente usando l'incremento postfisso in cui il prefisso sarebbe stato sufficiente.

++i è un pre-incremento; i++ è post-incremento.
Lo svantaggio del post-incremento è che genera un valore aggiuntivo; restituisce una copia del vecchio valore durante la modifica di i . Quindi, dovresti evitarlo quando ansible.

Con numeri interi, è la preferenza.

Se la variabile loop è una class / object, può fare la differenza (solo la profilazione può dirti se è una differenza significativa), perché la versione post-incremento richiede che tu crei una copia di quell’object che viene scartato.

Se la creazione di tale copia è un’operazione costosa, si pagano tali spese una volta ogni volta che si passa attraverso il ciclo, senza alcun motivo.

Se prendi l’abitudine di usare sempre ++i per loop, non devi fermarti e pensare se quello che stai facendo in questa particolare situazione ha senso. Lo sei sempre e basta.

C’è una ragione per questo: le prestazioni. i ++ genera una copia, e questo è uno spreco se lo scarti immediatamente. Certo, il compilatore può ottimizzare questa copia se sono un primitivo, ma non può se non lo è. Vedi questa domanda

Nessun compilatore che valga il suo peso in sale verrà eseguito in modo diverso tra

 for(int i=0; i<10; i++) 

e

 for(int i=0;i<10;++i) 

++ I e I ++ hanno lo stesso costo . L'unica cosa che differisce è che il valore di ritorno di ++ i è i + 1 mentre il valore di ritorno di i ++ è i.

Quindi per quelli che preferiscono ++ i, probabilmente non esiste una giustificazione valida, ma solo una preferenza personale.

EDIT: Questo è sbagliato per le classi, come detto in circa ogni altro post. i ++ genererà una copia se io sono una class.

Come altri hanno già notato, il pre-incremento di solito è più veloce del post-incremento per i tipi definiti dall’utente. Per capire perché è così, guarda il tipico schema del codice per implementare entrambi gli operatori:

 Foo& operator++() { some_member.increase(); return *this; } Foo operator++(int dummy_parameter_indicating_postfix) { Foo copy(*this); ++(*this); return copy; } 

Come puoi vedere, la versione del prefisso modifica semplicemente l’object e lo restituisce per riferimento.

La versione postfix, d’altra parte, deve eseguire una copia prima che venga eseguito l’incremento effettivo, quindi tale copia viene copiata di nuovo al chiamante in base al valore. È ovvio dal codice sorgente che la versione postfix deve fare più lavoro, perché include una chiamata alla versione prefisso: ++(*this);

Per i tipi built-in, non fa alcuna differenza finché si elimina il valore, cioè finché non si incorpora ++i o i++ in un’espressione più grande come a = ++i o b = i++ .

Preferenza personale.

Generalmente. A volte conta ma, per non sembrare uno stronzo qui, ma se devi chiedere, probabilmente no.

quando usi postfix crea istanze su più oggetti in memoria. Alcuni dicono che è meglio usare l’operatore suffix in loop