Was ist der Unterschied zwischen ++i und i++?

Question

Was ist in C der Unterschied zwischen der Verwendung von ++i y i++ und die im Inkrementierungsblock einer for Schleife?

Answer 1

++i (Präfix-Operation): Inkrementiert und weist dann den Wert zu
(z.B.): int i = 5 , int b = ++i In diesem Fall wird b zuerst die 6 zugewiesen und dann inkrementell die 7 und so weiter.

i++ (Postfix-Betrieb): Weist den Wert zu und erhöht ihn dann
(z.B.): int i = 5 , int b = i++ In diesem Fall wird b zuerst 5 zugewiesen und dann inkrementell 6 und so weiter.

Im Falle der for-Schleife: i++ wird meistens verwendet, weil wir normalerweise den Startwert von i vor der Inkrementierung in der for-Schleife. Je nach Programmlogik kann dies jedoch variieren.

Answer 2

i++ und ++i

Dieser kleine Code kann helfen, den Unterschied aus einem anderen Blickwinkel als dem der bereits veröffentlichten Antworten zu veranschaulichen:

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

Das Ergebnis ist:

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

Achten Sie auf die Vorher-Nachher-Situation.

for-Schleife

Was die Frage anbelangt, welche von ihnen in einem Inkrementierungsblock einer for-Schleife verwendet werden sollte, so denke ich, dass wir am besten anhand eines guten Beispiels eine Entscheidung treffen können:

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

Das Ergebnis ist:

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

Ich weiß nicht, wie es Ihnen geht, aber ich sehe keinen Unterschied in der Verwendung, zumindest nicht in einer for-Schleife.

Answer 3

Das folgende C-Codefragment veranschaulicht den Unterschied zwischen den Inkrement- und Dekrementoperatoren vor und nach der Eingabe:

int  i;
int  j;

Operatoren inkrementieren:

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

Answer 4

In Kürze:

++i y i++ funktioniert auch, wenn Sie sie nicht in eine Funktion schreiben. Wenn Sie etwas verwenden wie function(i++) o function(++i) können Sie den Unterschied sehen.

function(++i) besagt, dass zunächst i um 1 erhöht wird, danach wird Folgendes eingegeben i in die Funktion mit neuem Wert.

function(i++) sagt der erste Satz i in die Funktion einfügen, nachdem sie das Inkrement i von 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 5

Pre-Crement bedeutet Inkrement in der gleichen Zeile. Post-Inkrement bedeutet Inkrement nach der Ausführung der Zeile.

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

Mit den Operatoren OR und AND wird es noch interessanter.

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
}

In C++ post/pre-increment von Zeigervariablen

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