prefisso e suffisso non sono necessari, sono solo scorciatoie.

y = x++;

significa

y = x;
x = x + 1;

tuttavia     y = ++ x; mezzi

x = x + 1;
y = x;

Allo stesso modo, chiamare la funzione f come f(x++) non equivale a dire f(++x)

Nel linguaggio C, il suffisso postfix vs. applica i loro incrementi in momenti diversi e quindi ha effetti cruciali sulla logica del codice: %pr_e%

Questa linea:    while (++ i < MAX) {...} // imposta i a 1, quindi confronta 1 a MAX
è molto diverso da    while (i ++ < MAX) {...} // confronta da 0 a MAX, quindi imposta i a 1

Sì, questi operatori potrebbero essere scorciatoie a volte, ma qui la differenza è molto utile.

- pete

Se l'operazione si trova in una classe in cui una copia è un'operazione costosa e non è stata implementata correttamente come riferimento, potrebbe essere importante.

Per POD: codice che rende il codice più leggibile

Per il beneficio di persone diverse da Kenneth, il punto dell'operatore del prefisso è "incrementare questo", e il punto dell'operatore postfisso è "incrementare questo, ma se sono usato in un'espressione più lunga, usa il vecchio valore, non il nuovo valore ".

Quindi, ogni volta che vengono utilizzati in un'espressione più ampia, in genere generano risultati diversi tra loro. Ad esempio, confronta:

int countdown = 10;
while (countdown != 0) {
  cout << (countdown++) << "...\n";
}
cout << "BOOM!";

con:

int countdown = 11;
while (countdown >=1 ) {
  cout << (--countdown) << "...\n";
}
cout << "BOOM!";

o

int countdown = 10;
do {
  cout << (countdown) << "...\n";
  --countdown;
} while (countdown);
cout << "BOOM!";

Notate le sottili differenze. Per me, questo esempio è più facile quando (1) il numero inizializzato se il primo numero è stampato (2) il decremento fa parte dell'espressione più grande. (Nella vita reale, dovresti usare un ciclo "for" per questo particolare esempio, ma penso che ci saranno sempre degli esempi in cui prefisso o postfix è leggermente più chiaro.)

Tuttavia

Tuttavia, nella scrittura di codice moderna, il 99% delle volte trovo più facile leggere a lungo termine se l'incremento è sempre un'istruzione separata, anche se è leggermente più lungo. Quindi la differenza in realtà non conta davvero, se ci fosse solo un operatore di incremento che non può essere usato in un'espressione stessa, mi interesserebbe di rado.

Sommario

1. Se usi un'espressione postfissa o prefisso operatori di incremento in un'espressione, dovresti usare quello che fa ciò che intendi, non l'altro. Se non lo fai, otterrai quasi sempre la risposta sbagliata [1].

2. Tuttavia, di solito NON li usi in un'espressione, nel qual caso non importa molto che usi.

3. Ma se non ha importanza, usa il prefisso perché dichiara che la tua intenzione di "incrementare senza preoccuparti del valore di ritorno" è migliore e potrebbe occasionalmente impattare sul rendimento (vedi la domanda collegata nei commenti sotto l'articolo ).

[1] Anche essere consapevoli dei soliti avvertimenti come mai aumentare lo stesso valore due volte in una dichiarazione. Questo non funziona o non fa ciò che ti aspetti dalla maggior parte dei compilatori, e non sarebbe chiaro neanche se lo facesse.

Code Golf

Quando devi eseguire iterazioni in casi particolari con quantità di codice molto piccole, gli operatori di prefissi e post-fix possono fare alcune significative differenze di caratteri.

In qualsiasi altra situazione, sono aspartame sintattici in quanto possono portare a confusione quando non stai prestando molta attenzione a quale ordine si svolgono le operazioni.

In C ++ se hai un oggetto che ha un sovraccarico ++ e stai attraversando un ciclo che genera il numero x di detti oggetti, postfix può essere piuttosto costoso.

L'ho fatto su tipi numerici speciali che ho creato.

vector<Fraction> values;
Fraction base;
for(int i=0; i<someVar; i++)  //shouldn't do that "i++" cuz it is inconsitent..but i do
{   
    values.push_back(Fraction);
    ++Fraction;
}

Questo è un esempio, non penso di averlo usato in un loop di questo tipo, ma ne avevo bisogno nei loop con tipo Fraction.

I codice in una forma altrimenti obsoleta di assemblaggio, per lo più, forse l'ho già dimenticato, ma credo che questo sia utile nel ciclo se si vuole usare il contatore all'interno del ciclo senza che venga incrementato all'inizio del ciclo.

In qualche modo sull'argomento, questa domanda ha alcuni semplici esempi di utilizzo in java: link

No, non ci sono applicazioni del mondo reale.

Gli operatori pre-e postfix sono solo una comodità ( zucchero sintattico se ti piace). Ci sono molti linguaggi che non hanno affatto questi operatori (Python, per esempio). In ogni caso è sempre semplice modificare il codice da pre-post o viceversa e non avere alcun impatto sul risultato.