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




10 Answers

  • ++i incrementerò il valore di i e restituirò il valore incrementato.

     i = 1;
     j = ++i;
     (i is 2, j is 2)
    
  • i++ incrementerà il valore di i , ma restituirà il valore originale che i tenuto prima di essere incrementato.

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

Per un ciclo for , o funziona. ++i sembra più comune, forse perché è quello che viene usato in K&R

In ogni caso, seguire le linee guida "prefer ++i over i++ " e non si sbaglia.

Ci sono un paio di commenti riguardo l'efficienza di ++i e i++ . In qualsiasi compilatore di progetti non studenti, non ci saranno differenze di rendimento. Puoi verificarlo guardando il codice generato, che sarà identico.

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

Come per le note di Freund , è diverso per un oggetto C ++, dato che l' operator++() è una funzione e il compilatore non può sapere di ottimizzare la creazione di un oggetto temporaneo per contenere il valore intermedio.

preincremento ic

In C, qual è la differenza tra l'uso di ++i e i++ e quale dovrebbe essere usato nel blocco di incremento di un ciclo for ?




Si prega di non preoccuparsi dell '"efficienza" (velocità, in realtà) di cui si è più veloci. Abbiamo compilatori in questi giorni che si prendono cura di queste cose. Usa quello che ha senso usare, in base al quale mostra più chiaramente il tuo intento.




i ++: - In questo scenario prima viene assegnato il valore e quindi si verifica un incremento.

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

Di seguito la visualizzazione dell'immagine e anche qui un bel video pratico ( http://www.youtube.com/watch?v=lrtcfgbUXm4 ) che dimostra lo stesso.




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

In termini di efficienza, potrebbe esserci una penalità legata alla scelta di i ++ over ++ 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 comprendere che sta vedendo un incremento intero in un ciclo for, e ottimizzerà entrambi i metodi con lo stesso codice efficiente. Se l'utilizzo del post-incremento rispetto al pre-incremento fa sì che il tuo programma abbia un tempo di esecuzione più lento, allora stai usando un terribile compilatore.

  2. In termini di complessità operativa del tempo, 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 loop di dimensioni significative, la penalità del metodo di incremento verrà messa in ombra in modo massivo dall'esecuzione del corpo del loop. In altre parole, è molto meglio preoccuparsi di ottimizzare il codice nel ciclo piuttosto che l'incremento.

A mio parere, l'intera questione si riduce semplicemente a una preferenza di stile. Se pensi che il pre-incremento sia più leggibile, allora usalo. Personalmente, preferisco la post-incrusione, ma probabilmente è perché è stato quello che mi è stato insegnato prima di sapere qualcosa sull'ottimizzazione.

Questo è un esempio per eccellenza di ottimizzazione prematura, e problemi come questo hanno il potenziale di distrarci da seri problemi di progettazione. Rimane comunque una buona domanda, perché non c'è uniformità nell'uso o nel consenso nelle "migliori pratiche".




++ i è pre-incrementare l'altro è post-incremento

i ++: ottiene l'elemento e quindi lo incrementa.
++ i: incrementa i e 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



Presumo che tu capisca la differenza nella semantica ora (anche se onestamente mi chiedo perché la gente chieda "cosa significa X operatore" domande sullo piuttosto che leggere, sai, un libro o un tutorial sul web o qualcosa del genere.

Ma comunque, per quanto riguarda l'uso, ignorate le domande sulle prestazioni, che sono improbabili anche in C ++. Questo è il principio che dovresti usare quando decidi quale usare:

Dì cosa intendi nel codice.

Se non è necessario il valore prima dell'incremento nella dichiarazione, non utilizzare tale modulo 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'altro (ovvero una guida di stile con le ossa), dovresti usare il modulo che esprime esattamente ciò che stai cercando di fare.

QED, usa la versione pre-incremento:

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



La differenza principale è

  • Post i ++ ( dopo l'incremento ) e
  • ++ i Pre ( prima dell'incremento )

    • post se i =1 il loop aumenta come 1,2,3,4,n
    • pre se i =1 il loop aumenta come 2,3,4,5,n



Pre-crement significa incremento sulla stessa linea. 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 viene fornito con operatori OR, 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
}

In 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 pointer

#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)
}



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 

Presta attenzione alle situazioni prima e dopo.

per ciclo

Per quanto riguarda quale di essi dovrebbe essere usato 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.




a = i ++ significa che contiene valore corrente i a = ++ i significa a contiene valore i incrementato




Related