Cos’è più efficiente i ++ o ++ i?

Duplicazione esatta : esiste una differenza di prestazioni tra i ++ e ++ i in C ++?
Duplicazione esatta : differenza tra i ++ e ++ i in un ciclo?


Cos’è più efficiente i ++ o ++ i?

L’ho usato solo in Java e C / C ++, ma in realtà sto chiedendo tutte le lingue in cui è implementato.

All’università ho avuto un professore che ci mostra che ++ ero più efficiente ma è stato un paio d’anni e vorrei ricevere input dalla comunità SO.

i ++:

  • creare una copia temporanea di i
  • incremento i
  • restituire la copia temporanea

++ i:

  • incremento i
  • ritorno i

Con le ottimizzazioni triggerste, è del tutto ansible che l’assembly risultante sia identico, tuttavia ++ i è più efficiente.

modifica: tieni presente che in C ++, posso essere qualsiasi object che supporti l’operatore prefisso e postfix ++. Per oggetti complessi, il costo della copia temporanea non è trascurabile.

Vorrei cercare altrove il potenziale di ottimizzazione.

Ecco cosa pensa SO del prefisso C ++ e dell’incremento postfix

L’efficienza non dovrebbe essere la vostra preoccupazione: è un significato . I due non sono gli stessi, a meno che non siano indipendenti: uno gestisce il pre-utilizzo del valore, l’altro post.

int i; i = 1; cout << i ++; // restituisce 1

int i; i = 1; cout << ++ i; // Restituisce 2

Quando il significato non è importante, la maggior parte dei compilatori tradurrà sia ++ i che i ++ (ad esempio in un ciclo for) nello stesso codice macchina / VM.

Non importa su un compilatore moderno.

int v = i++; 

equivale a

 int v = i; i = i + 1; 

Un moderno compilatore scoprirà che v è inutilizzato e il codice per calcolare v è puro (senza effetti collaterali). Quindi rimuoverà v e il codice di assegnazione e genererà questo

 i = i + 1; 

Importa! Soprattutto se sei su C ++ …

 ++i // the prefered way, unless.. auto j = i++ // this is what you need 

Si dovrebbe sempre usare la notazione del prefisso per evitare di copiare le spese necessarie e con C ++ questo è importante!

Bene, in C ++ credo che abbiano usi diversi, a seconda di quando si desidera aggiornare la variabile. L’efficienza non dovrebbe determinare quando si utilizza l’una sull’altra, ma suppongo che avrebbero la stessa efficienza in entrambi i casi.

++ I è potenzialmente più efficiente per un’implementazione non banale di operatore ++, ma anche in tale scenario, il compilatore può essere in grado di ottimizzare il temporaneo intermedio.

++ Non ho bisogno di una variabile temporanea per archiviare cose. Pensa a loro in questo modo:

++ i

 int preIncrement(int i) { i = i + 1; return i; } 

i ++

 int i = 5; // as an example int postIncrement(_i) { int temp = _i; i = _i + 1; return temp; } 

Vedere? Postincremento richiede una variabile temporanea. Supponendo che il compilatore non risolva tutto per te, cosa che quasi sicuramente fa.

Certo, più importante è la logica del programma; corri il rischio di incontrare Triste Tristezza del Micro-Optimization Theatre se ti preoccupi troppo di questo … 🙂

A meno che mi manchi qualcosa, dovrebbero avere la stessa efficienza. Dovrebbero entrambi risultare in una singola istruzione di aggiunta. È solo questione di dove si svolgono le istruzioni di aggiunta: all’inizio o alla fine della linea di codice.

Non c’è differenza. Usa il costrutto che ha più senso.

Se la tua applicazione funziona lentamente, ti garantisco che non sarà mai a causa delle differenze di velocità nell’operazione di incremento dei numeri interi. Se lo è, si tratta di un bug grave nel compilatore. I problemi di velocità nella tua applicazione saranno inefficienze algoritmiche, in attesa di IO e così via.

Non preoccuparti di problemi che non hai. L’ottimizzazione prematura è la radice di tutto il male.

++i è più veloce perché i++ deve memorizzare i , quindi incrementarlo, quindi restituire il valore memorizzato di i . ++i semplicemente incrementi poi lo restituisce.

 // ++i i += 1; return i; // i++ temp = i; i += 1; return temp; 

Un “i ++” autonomo o “++ i;” dovrebbe generare codice altrettanto efficiente. La differenza arriva se la stai usando in un’espressione, dove entra in gioco l ‘”effetto collaterale”.

Detto questo, ci fu un tempo, quando “tutto il mondo è un Vax”, e i compilatori risucchiati, che ++ mi è stato detto più efficiente di i ++, anche in un “for (i = 0; i

Questa domanda StackOverflow ha una grande risposta: Esiste una differenza di prestazioni tra i ++ e ++ i in C?

Vorrei aggiungere che dovresti usare quello che meglio si adatta alle tue esigenze. Tranne che nel momento più critico delle applicazioni, non è importante. Anche dal punto di vista accademico, è meglio scrivere un codice che esprima ciò di cui hai bisogno e ottimizzi finalmente.

Non c’è una risposta giusta o sbagliata

Dal momento che dipende

1) come è stato implementato dal compilatore

2) su quale CPU viene eseguito il sistema

3) Se I è byte o I double word

In generale, è più efficiente usare ++ i rispetto a i ++. La semplice ragione per questo è che ++ i è assolutamente uguale a

i + = 1;

che per x86 è una singola istruzione (e probabilmente la maggior parte delle altre architetture ampiamente utilizzate). i ++ è comunque uguale a

tmp = i; i + = 1;

Questo perché il vecchio valore di “i” è ciò che valuta a ++. E chiaramente ciò richiede più lavoro che semplicemente i + = 1;

Ma come detto sopra, questo non ha praticamente alcun impatto con un compilatore sufficientemente intelligente, in quanto ottimizzerà le operazioni inutilizzate. Per molti linguaggi interpretati (esempio: PHP) c’è probabilmente un guadagno minimo di velocità per il ++ i; Ma questo aumento è trascurabile.

Generalmente, in c ++, postfix richiede la costruzione aggiuntiva dell’object incrementato, mentre il prefisso viene applicato direttamente all’object. (O così ho letto)

Poiché non sono in grado di attestare il modo in cui il compilatore lo gestisce a causa delle mie conoscenze limitate sull’argomento, potrebbe essere gestito per te rendendolo un punto controverso.

++ Prendo 1 istruzione del processore in meno di I ++ nell’assemblaggio x86 senza ottimizzazione

In genere è più semplice digitare i ++, quindi è più efficiente in termini di tempo di produttività.

Seriamente, però, se sono un tipo di dati nativo (come int, double, ecc.) – nessuna differenza.

Ed è l’implementazione dipende se è un tipo definito dall’utente come

 class Type { Type& operator ++(){} const Type& operator ++(int i){} }; T i; 

Dipende dal contesto, ad esempio:

 x = i++ 

In questo caso, ‘x’ sarà uguale a ‘i’, e solo dopo che ‘i’ sarà aumentato di uno.

 x = ++i 

In questo caso, ‘i’ aumenterà di uno e quindi il nuovo valore di ‘x’ sarà assegnato a ‘x’.

Nel caso di un ciclo ‘for’, c’è poca differenza apparente oltre alla performance (++ i è più veloce).

È difficile rispondere con precisione poiché dipende dall’implementazione del compilatore / interprete.

Ma in generale si può dire approssimativamente estendere i ++ alle seguenti istruzioni:

 COPY i to tmp INCREMENT tmp SAVE tmp as i 

Mentre ++ I si estenderà approssimativamente a:

 LOAD i INCREMENT i 

Non si può semplicemente dire che ++ i è più veloce di I ++ poiché le implementazioni linguistiche sono abbastanza intelligenti e possono ottimizzare queste istruzioni quando si sa che non si accederà al valore temporaneo di i ++. Questo di solito accade in un ciclo for. Quindi in molti casi è lo stesso.

Se stai provando a questo tipo di micro-ottimizzazioni ti consiglierei di profilare / misurare prima di sceglierne uno rispetto all’altro.