Qual è la differenza tra ++i e i++?

Question

In C, qual è la differenza tra l'utilizzo ++i E i++, e che dovrebbe essere utilizzato nel blocco di incremento di a for ciclo continuo?

Answer 1

• ++i incrementerà il valore di i, e quindi restituire il valore incrementato.

   i = 1;
   j = ++i;
   (i is 2, j is 2)
  

• i++ incrementerà il valore di i, ma restituisce il valore originale that i tenuto prima di essere incrementato.

   i = 1;
   j = i++;
   (i is 2, j is 1)
  

Per un for loop, entrambi funzionano. ++i sembra più comune, forse perché è quello che viene utilizzato K&R.

In ogni caso seguire la linea guida "preferire ++i Sopra i++"e non sbaglierai.

Ci sono un paio di commenti riguardanti l'efficienza di ++i E i++.In qualsiasi compilatore di progetti non studenteschi, non ci sarà alcuna differenza di prestazioni.Puoi verificarlo guardando il codice generato, che sarà identico.

La questione dell'efficienza è interessante...ecco il mio tentativo di risposta:C'è una differenza di prestazioni tra i++ e ++i in C?

COME Su Freund note, è diverso per un oggetto C++, poiché operator++() è una funzione e il compilatore non può sapere come ottimizzare la creazione di un oggetto temporaneo per contenere il valore intermedio.

Answer 2

i++ è conosciuto come Incremento postale mentre ++i è chiamato Preincremento.

i++

i++ è post incremento perché incrementa idi 1 al termine dell'operazione.

Vediamo il seguente esempio:

int i = 1, j;
j = i++;

Qui valore di j = 1 Ma i = 2.Qui valore di i verrà assegnato a j prima poi i verrà incrementato.

++i

++i è preincremento perché incrementa idi 1 prima dell'operazione.Significa j = i; verrà eseguito dopo i++.

Vediamo il seguente esempio:

int i = 1, j;
j = ++i;

Qui valore di j = 2 Ma i = 2.Qui valore di i verrà assegnato a j dopo il i incremento di i.Allo stesso modo ++i verrà eseguito prima j=i;.

Per la tua domanda quale dovrebbe essere utilizzato nel blocco di incremento di un ciclo for? la risposta è che puoi usarne uno qualsiasi..non importa.Eseguirà il tuo ciclo for stesso no.di volte.

for(i=0; i<5; i++)
   printf("%d ",i);

E

for(i=0; i<5; ++i)
   printf("%d ",i);

Entrambi i cicli produrranno lo stesso output.cioè 0 1 2 3 4.

Importa solo dove lo usi.

for(i = 0; i<5;)
    printf("%d ",++i);

In questo caso l'output sarà 1 2 3 4 5.

Answer 3

Per favore, non preoccuparti dell '"efficienza" (velocità, in realtà) di chi è più veloce.Al giorno d'oggi abbiamo compilatori che si prendono cura di queste cose.Usa quello che ha senso usare, in base al quale mostra più chiaramente il tuo intento.

Answer 4

++i incrementa il valore, quindi lo restituisce.

i++ restituisce il valore e quindi lo incrementa.

È una differenza sottile.

Per un ciclo for, utilizzare ++i, poiché è leggermente più veloce. i++ creerà una copia extra che verrà semplicemente buttata via.

Answer 5

i++:In questo scenario prima viene assegnato il valore e poi avviene l'incremento.

++i:In questo scenario prima viene eseguito l'incremento e poi viene assegnato il valore

Di seguito è riportata la visualizzazione dell'immagine e anche ecco un bel video pratico che dimostra lo stesso.

Answer 6

La ragione ++i Potere essere leggermente più veloce di i++ è questo i++ può richiedere una copia locale del valore di i prima che venga incrementato, mentre ++i non lo fa mai.In alcuni casi, alcuni compilatori lo ottimizzeranno, se possibile...ma non è sempre possibile e non tutti i compilatori lo fanno.

Cerco di non fare troppo affidamento sulle ottimizzazioni dei compilatori, quindi seguirei il consiglio di Ryan Fox:quando posso usarli entrambi, uso ++i.

Answer 7

Il risultato effettivo dell'utilizzo di entrambi è identico.In altre parole, il ciclo farà la stessa identica cosa in entrambi i casi.

In termini di efficienza, potrebbe esserci una penalità nella scelta di i++ rispetto a ++i.In termini di specifiche del linguaggio, l'utilizzo dell'operatore post-incremento dovrebbe creare una copia aggiuntiva del valore su cui agisce l'operatore.Questa potrebbe essere una fonte di operazioni extra.

Tuttavia, dovresti considerare due problemi principali con la logica precedente.

1. I compilatori moderni sono fantastici.Tutti i buoni compilatori sono abbastanza intelligenti da rendersi conto che sta vedendo un incremento di un numero intero in un ciclo for e ottimizzerà entrambi i metodi per lo stesso codice efficiente.Se l'utilizzo del post-incremento rispetto al pre-incremento fa effettivamente sì che il programma abbia un tempo di esecuzione più lento, allora stai utilizzando un terribile compilatore.

2. In termini di complessità temporale operativa, i due metodi (anche se viene effettivamente eseguita una copia) sono equivalenti.Il numero di istruzioni eseguite all'interno del ciclo dovrebbe dominare in modo significativo il numero di operazioni nell'operazione di incremento.Pertanto, in qualsiasi ciclo di dimensioni significative, la penalità del metodo di incremento sarà ampiamente oscurata dall'esecuzione del corpo del ciclo.In altre parole, è molto meglio preoccuparsi dell'ottimizzazione del codice nel ciclo piuttosto che dell'incremento.

Secondo me, l’intera questione si riduce semplicemente a una preferenza di stile.Se ritieni che il pre-incremento sia più leggibile, utilizzalo.Personalmente preferisco il post-incremento, ma probabilmente è perché è quello che mi è stato insegnato prima che sapessi qualcosa sull'ottimizzazione.

Questo è un esempio tipico di ottimizzazione prematura e problemi come questo hanno il potenziale per distrarci da problemi seri nella progettazione.È comunque una buona domanda da porsi, perché non c'è uniformità nell'uso o consenso nella "migliore pratica".

Answer 8

Entrambi incrementano il numero. ++i è equivalente a i = i + 1.

i++ E ++i sono molto simili ma non esattamente uguali.Entrambi incrementano il numero, ma ++i incrementa il numero prima che venga valutata l'espressione corrente, mentre i++ incrementa il numero dopo la valutazione dell'espressione.

Esempio:

int i = 1;
int x = i++; //x is 1, i is 2
int y = ++i; //y is 3, i is 3

Answer 9

++i (Operazione prefisso):Incrementa e quindi assegna il valore
(per esempio): int i = 5, int b = ++iIn questo caso, 6 viene assegnato prima a b, quindi aumenta fino a 7 e così via.

i++ (Operazione suffissa):Assegna e quindi incrementa il valore
(per esempio): int i = 5, int b = i++In questo caso, 5 viene assegnato prima a b, quindi aumenta fino a 6 e così via.

In caso di ciclo for: i++ viene utilizzato principalmente perché normalmente utilizziamo il valore iniziale di i prima di incrementare il ciclo for.Ma a seconda della logica del programma, può variare.

Answer 10

++i:è pre-incremento, l'altro è post-incremento.

i++:ottiene l'elemento e quindi lo incrementa.
++i:incrementa i e quindi restituisce l'elemento.

Esempio:

int i = 0;
printf("i: %d\n", i);
printf("i++: %d\n", i++);
printf("++i: %d\n", ++i);

Produzione:

i: 0
i++: 0
++i: 2

Answer 11

Presumo che tu capisca la differenza in semantica ora (anche se onestamente mi chiedo perché le persone chiedano "cosa fa l'operatore X" domande sullo stack overflow piuttosto che leggere, sai, un libro o un tutorial web o qualcosa del genere.

Ma comunque, per quanto si utilizza, ignorare le domande di prestazioni, che sono improbabili importanti anche in C ++.Questo è il principio che dovresti usare quando si decide quale usare:

Dì cosa intendi in codice.

Se non hai bisogno del valore prima dell'incremento nella tua istruzione, non utilizzare quella forma dell'operatore.È un problema minore, ma a meno che tu non stia lavorando con una guida di stile che vieta una versione a favore dell'altra del tutto (aka una guida in stile dalla testa di ossa), dovresti usare la forma che più esprime esattamente ciò che stai cercando di fare.

QED, utilizza la versione pre-incremento:

for (int i = 0; i != X; ++i) ...

Answer 12

La differenza può essere compresa da questo semplice codice C++ riportato di seguito:

int i, j, k, l;
i = 1; //initialize int i with 1
j = i+1; //add 1 with i and set that as the value of j. i is still 1
k = i++; //k gets the current value of i, after that i is incremented. So here i is 2, but k is 1
l = ++i; // i is incremented first and then returned. So the value of i is 3 and so does l.
cout << i << ' ' << j << ' ' << k << ' '<< l << endl;
return 0;

Answer 13

La differenza principale è

• i++ Messaggio(Dopo l'incremento) E

• ++i Pre (Prima dell'incremento)

  • pubblica se i =1 il ciclo incrementa come 1,2,3,4,n
  • pre se i =1 il ciclo incrementa come 2,3,4,5,n

Answer 14

i++ e ++i

Questo piccolo codice può aiutare a visualizzare la differenza da un'angolazione diversa rispetto alle risposte già pubblicate:

int i = 10, j = 10;

printf ("i is %i \n", i);
printf ("i++ is %i \n", i++);
printf ("i is %i \n\n", i);

printf ("j is %i \n", j);
printf ("++j is %i \n", ++j);
printf ("j is %i \n", j);

Il risultato è:

//Remember that the values are i = 10, and j = 10

i is 10 
i++ is 10     //Assigns (print out), then increments
i is 11 

j is 10 
++j is 11    //Increments, then assigns (print out)
j is 11 

Prestare attenzione alle situazioni prima e dopo.

per ciclo

Per quanto riguarda quale di essi dovrebbe essere utilizzato in un blocco di incremento di un ciclo for, penso che il meglio che possiamo fare per prendere una decisione sia usare un buon esempio:

int i, j;

for (i = 0; i <= 3; i++)
    printf (" > iteration #%i", i);

printf ("\n");

for (j = 0; j <= 3; ++j)
    printf (" > iteration #%i", j);

Il risultato è:

> iteration #0 > iteration #1 > iteration #2 > iteration #3
> iteration #0 > iteration #1 > iteration #2 > iteration #3 

Non so voi, ma non vedo alcuna differenza nel suo utilizzo, almeno in un ciclo for.

Answer 15

Il seguente frammento di codice C illustra la differenza tra gli operatori di incremento e decremento pre e post:

int  i;
int  j;

Operatori di incremento:

i = 1;
j = ++i;    // i is now 2, j is also 2
j = i++;    // i is now 3, j is 2

Answer 16

Pre-incremento significa incremento sulla stessa riga.Post-incremento significa incremento dopo l'esecuzione della riga.

int j=0;
System.out.println(j); //0
System.out.println(j++); //0. post-increment. It means after this line executes j increments.

int k=0;
System.out.println(k); //0
System.out.println(++k); //1. pre increment. It means it increments first and then the line executes

Quando si tratta degli operatori OR e AND, diventa più interessante.

int m=0;
if((m == 0 || m++ == 0) && (m++ == 1)) { //false
/* in OR condition if first line is already true then compiler doesn't check the rest. It is technique of compiler optimization */
System.out.println("post-increment "+m);
}

int n=0;
if((n == 0 || n++ == 0) && (++n == 1)) { //true
System.out.println("pre-increment "+n); //1
}

Nella matrice

System.out.println("In Array");
int[] a = { 55, 11, 15, 20, 25 } ;
int ii, jj, kk = 1, mm;
ii = ++a[1]; // ii = 12. a[1] = a[1] + 1
System.out.println(a[1]); //12

jj = a[1]++; //12
System.out.println(a[1]); //a[1] = 13

mm = a[1];//13
System.out.printf ( "\n%d %d %d\n", ii, jj, mm ) ; //12, 12, 13

for (int val: a) {
     System.out.print(" " +val); //55, 13, 15, 20, 25
}

In C++ post/pre-incremento della variabile puntatore

#include <iostream>
using namespace std;

int main() {

    int x=10;
    int* p = &x;

    std::cout<<"address = "<<p<<"\n"; //prints address of x
    std::cout<<"address = "<<p<<"\n"; //prints (address of x) + sizeof(int)
    std::cout<<"address = "<<&x<<"\n"; //prints address of x

    std::cout<<"address = "<<++&x<<"\n"; //error. reference can't re-assign because it is fixed (immutable)
}

Answer 17

In breve:

++i E i++ funziona allo stesso modo se non li stai scrivendo in una funzione.Se usi qualcosa del genere function(i++) O function(++i) puoi vedere la differenza.

function(++i) dice il primo incremento i di 1, dopodiché inserisci questo i nella funzione con un nuovo valore.

function(i++) dice "metti per primo". i nella funzione dopo tale incremento i entro 1.

int i=4;
printf("%d\n",pow(++i,2));//it prints 25 and i is 5 now
i=4;
printf("%d",pow(i++,2));//it prints 16 i is 5 now

Answer 18

L'unica differenza è l'ordine delle operazioni tra l'incremento della variabile e il valore restituito dall'operatore.

Questo codice e il suo output spiegano la differenza:

#include<stdio.h>

int main(int argc, char* argv[])
{
  unsigned int i=0, a;
  a = i++;
  printf("i before: %d; value returned by i++: %d, i after: %d\n", i, a, i);
  i=0;
  a = ++i;
  printf("i before: %d; value returned by ++i: %d, i after: %d\n", i, a, i);
}

L'output è:

i before: 1; value returned by i++: 0, i after: 1
i before: 1; value returned by ++i: 1, i after: 1

Quindi in poche parole ++i restituisce il valore dopo che è stato incrementato, mentre ++i restituisce il valore prima che venga incrementato.Alla fine, in entrambi i casi il i avrà il suo valore incrementato.

Un altro esempio:

#include<stdio.h>

int main ()
  int i=0;
  int a = i++*2;
  printf("i=0, i++*2=%d\n", a);
  i=0;
  a = ++i * 2;
  printf("i=0, ++i*2=%d\n", a);
  i=0;
  a = (++i) * 2;
  printf("i=0, (++i)*2=%d\n", a);
  i=0;
  a = (++i) * 2;
  printf("i=0, (++i)*2=%d\n", a);
  return 0;
}

Produzione:

i=0, i++*2=0
i=0, ++i*2=2
i=0, (++i)*2=2
i=0, (++i)*2=2

---

Molte volte non c'è differenza

Le differenze sono evidenti quando il valore restituito viene assegnato a un'altra variabile o quando l'incremento viene eseguito in concatenazione con altre operazioni in cui viene applicata la precedenza delle operazioni (i++*2 è diverso da ++i*2, Ma (i++)*2 E (++i)*2 restituisce lo stesso valore) in molti casi sono intercambiabili.Un esempio classico è la sintassi del ciclo for:

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

ha lo stesso effetto di

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

Regola da ricordare

Per non fare confusione tra i due operatori ho adottato questa regola:

Associa la posizione dell'operatore ++ rispetto alla variabile i all'ordine del ++ operazione rispetto all’incarico

Detto in altre parole:

• ++ Prima i significa che è necessario eseguire l'incremento Prima Incarico;
• ++ Dopo i significa che è necessario eseguire l'incremento Dopo Incarico:

Answer 19

Puoi pensare alla conversione interna di ciò come a molteplici dichiarazioni;

// case 1 :

i++;

/* you can think as,
 * i;
 * i= i+1;
 */

// case 2

++i;

/* you can think as,
 * i = i+i;
 * i;
 */

Answer 20

a = i ++ significa che A contiene il valore di corrente i a = ++ I significa che a contiene valore I incrementato

Answer 21

Ecco l'esempio per capire la differenza

int i=10;
printf("%d %d",i++,++i);

produzione: 10 12/11 11 (a seconda dell'ordine di valutazione degli argomenti al printf funzione, che varia a seconda dei compilatori e delle architetture)

Spiegazione:i++->i viene stampato, quindi incrementa.(Stampa 10, ma i diventeranno 11)++i->i valore aumenta e stampa il valore.(Stampa 12 e il valore di i anche 12)