I++ jest znany jako Post Increment podczas gdy ++i jest nazywany Pre Increment.

i++

i++ jest post incrementem, ponieważ zwiększa wartość i o 1 po zakończeniu operacji.

Zobaczmy następujący przykład:

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

Tutaj wartość j = 1 ale i = 2. Tutaj wartość i zostanie przypisana do j najpierw i zostanie zwiększona.

++i

++i na pre increment, ponieważ zwiększa wartość i o 1 przed wykonaniem operacji. Oznacza to, że j = i; wykona po i++.

Zobaczmy następujący przykład:

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

Tutaj wartość j = 2 ale i = 2. Tutaj wartość i zostanie przypisana do j po przyrostku i z i. Podobnie {[13] } zostanie wykonane przed j=i;.

Dla Twojego pytania który powinien być użyty w bloku inkrementacji pętli for? odpowiedź brzmi: możesz użyć dowolnego.. nieważne. Spowoduje to wykonanie pętli for tego samego nie. razy.

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

I

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

Obie pętle będą produkować to samo wyjście. ie 0 1 2 3 4.

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

W tym przypadku wyjście będzie 1 2 3 4 5.

Proszę nie martwić się o "wydajność" (szybkość, naprawdę), z których jeden jest szybszy. W dzisiejszych czasach mamy Kompilatory, które zajmują się tymi rzeczami. Używaj tego, który ma sens, na podstawie którego wyraźniej pokazuje twoje intencje.

++i zwiększa wartość, a następnie zwraca ją.

i++ Zwraca wartość, a następnie ją zwiększa.

Dla pętli for, użyj ++i, ponieważ jest nieco szybsza. i++ stworzy dodatkową kopię, która zostanie wyrzucona.

I++: - w tym scenariuszu najpierw zostanie przypisana wartość, a następnie nastąpi inkrementacja.

++i :- w tym scenariuszu najpierw następuje przyrost, a następnie przypisana jest wartość

Poniżej jest wizualizacja obrazu, a także tutaj jest ładny praktyczny film ( http://www.youtube.com/watch?v=lrtcfgbUXm4 ), co dowodzi tego samego.

Powód ++i Może być nieco szybsze niż i++ jest to, że i++ może wymagać lokalnej kopii wartości i, zanim zostanie ona zwiększona, podczas gdy ++i nigdy tego nie robi. W niektórych przypadkach niektóre Kompilatory zoptymalizują go, jeśli to możliwe... ale nie zawsze jest to możliwe i nie wszystkie Kompilatory to robią.

Staram się nie polegać zbytnio na optymalizacjach kompilatorów, więc podążam za radą Ryana Foxa: Kiedy Mogę używać obu, używam ++i.

Efektywny wynik użycia obu jest identyczny. Innymi słowy, pętla zrobi dokładnie to samo w obu przypadkach.

Jeśli chodzi o wydajność, może być kara związana z wyborem i++ nad ++i. jeśli chodzi o specyfikację języka, użycie operatora post-increment powinno utworzyć dodatkową kopię wartości, na której działa operator. To może być źródłem dodatkowych operacji.

Należy jednak wziąć pod uwagę dwa główne problemy z poprzedzającym logika.

1. Nowoczesne Kompilatory są świetne. Wszystkie dobre Kompilatory są na tyle inteligentne, że zdają sobie sprawę, że widzą przyrost liczby całkowitej w pętli for i zoptymalizują obie metody do tego samego wydajnego kodu. Jeśli użycie post-increment nad pre - increment powoduje, że twój program działa wolniej, To używasz kompilatora terrible.

2. Jeśli chodzi o złożoność czasu pracy, dwie metody (nawet jeśli kopia jest faktycznie wykonywana) są równoważne. Liczba instrukcji wykonywanych wewnątrz pętli powinna znacząco zdominować liczbę operacji w operacji inkrementacji. W związku z tym, w każdej pętli o znaczącej wielkości, kara metody inkrementacji zostanie znacznie przyćmiona przez wykonanie ciała pętli. Innymi słowy, o wiele lepiej jest martwić się o optymalizację kodu w pętli, a nie przyrost.

Moim zdaniem cała sprawa sprowadza się po prostu do preferowany styl. Jeśli uważasz, że pre-increment jest bardziej czytelny, użyj go. Osobiście wolę post-incrment, ale to prawdopodobnie dlatego, że to było to, czego uczono mnie, zanim wiedziałem coś o optymalizacji.

Jest to kwintesencyjny przykład przedwczesnej optymalizacji, a takie kwestie mogą odwrócić naszą uwagę od poważnych problemów w projektowaniu. Jest to jednak nadal dobre pytanie, ponieważ w "najlepszych praktykach" nie ma jednolitości w stosowaniu ani konsensusu."

Obie zwiększają liczbę. ++i jest odpowiednikiem i = i + 1.

I++ I ++i są bardzo podobne, ale nie do końca takie same. Zarówno zwiększa liczbę, ale ++i zwiększa liczbę przed obliczeniem bieżącego wyrażenia, podczas gdy i++ zwiększa liczbę po obliczeniu wyrażenia.

Przykład:

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

++i jest pre-increment drugi jest post-increment

I++: pobiera element, a następnie go zwiększa.
++i: inkrementuje i, a następnie zwraca element

Przykład:

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

Wyjście:

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

++i (operacja przedrostka): przyrosty, a następnie przypisuje wartość
(eg): int i = 5, int b = ++i
W tym przypadku 6 jest najpierw przypisane do b, a następnie przyrosty do 7 i tak dalej.

I++ (operacja Postfix): przypisuje a następnie zwiększa wartość
(eg): int i = 5, int b = i++
W tym przypadku 5 jest najpierw przypisane do b, a następnie przyrosty do 6 i tak dalej.

Inkluzja for loop : i++ jest najczęściej używana, ponieważ zwykle używamy początkowego wartość i przed inkrementacją w pętli for.Ale w zależności od logiki programu może się różnić.

Zakładam, że teraz rozumiesz różnicę w semantyce (choć szczerze mówiąc zastanawiam się, dlaczego ludzie pytają "co oznacza operator x" o przepełnienie stosu, zamiast czytać, wiesz, książka albo samouczek internetowy czy coś.

Ale w każdym razie, jeśli chodzi o to, którego z nich użyć, ignoruj pytania dotyczące wydajności, które są mało ważne nawet w C++. To jest zasada, którą powinieneś stosować przy podejmowaniu decyzji którego użyć:

Jeśli nie potrzebujesz value-before-increment in your statement, don ' t use that form of the operator. To drobny problem, ale chyba, że pracujesz z przewodnikiem stylu, który zakazuje jednego wersja na korzyść innych (aka poradnik w stylu Kościana głowa), należy użyć forma, która najbardziej dokładnie wyraża to, co próbujesz zrobić.

QED, użyj wersji pre-increment:

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

Różnicę można zrozumieć za pomocą poniższego prostego kodu C++:

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;

Główna różnica to

• i++ Post ( Po przyroście ) i

• ++i Pre (Before Increment)

  • post if i =1 pętla zwiększa się jak 1,2,3,4,n
  • pre if i =1 pętla zwiększa się jak 2,3,4,5,n

Wkrótce : ++i i++ działa tak samo, jeśli nie piszesz ich w funkcji. Jeśli używasz czegoś takiego jak function(i++) lub function(++i), możesz zobaczyć różnicę.

Funkcja (++i) mówi pierwszy przyrost i o 1, następnie umieścić to i w funkcji z nową wartością.

Funkcja (i++) mówi umieścić pierwsze i do funkcji po tym przyrost i przez 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

Pre-crement oznacza przyrost na tej samej linii. Post-increment oznacza przyrost po wykonaniu linii.

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

Jeśli chodzi o Or i operatorów, staje się bardziej interesujące.

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 Array

        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
        }

W C++ post / pre-increment zmiennej wskaźnika

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

Poniższy fragment kodu C ilustruje różnicę między operatorami pre i post increment i decrement:

Int i; int j;

// operatory przyrostowe

I = 1;

J = ++I; / / i jest teraz 2, j jest również 2

J = I++; / / i jest teraz 3, j jest 2

I++ I ++i

Ten mały kod może pomóc wizualizować różnicę pod innym kątem niż już zamieszczone odpowiedzi:

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);

Wynik jest:

//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 

Zwróć uwagę na sytuacje Przed i po.

For loop

Jeśli chodzi o to, który z nich powinien być użyty w bloku inkrementacji pętli for, myślę, że najlepszym sposobem na podjęcie decyzji jest użycie dobrego przykładu:

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);

Wynik jest:

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

Nie wiem jak wy, ale nie widzę żadnej różnicy w jego użyciu, przynajmniej w pętli for.

Można myśleć o wewnętrznej konwersji tego jako wielokrotnych wyrażeń ;

// case 1 :

i++;

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

// case 2

++i;

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

A=i++ oznacza, że a Zawiera bieżącą wartość i a = ++i oznacza, że a Zawiera zwiększoną wartość i

Oto przykład, aby zrozumieć różnicę

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

Output: 10 12/11 11 (w zależności od kolejności ewaluacji argumentów funkcji printf, która różni się w zależności od kompilatorów i architektur)

Wyjaśnienie: i++->i jest drukowana, a następnie inkrementowana. (Drukuje 10, ale {[4] } będzie 11) ++i->i wartość zwiększa i drukuje wartość. (Wypisuje 12, a wartość i również 12)