Was ist der Unterschied zwischen Präfix- und Postfix-Operatoren?

Es gibt einen großen Unterschied zwischen Postfix- und Präfix-Versionen von ++.

In der Präfixversion (dh ++i) Wird der Wert von i inkrementiert und der Wert des Ausdrucks ist der neue Wert von i.

In der Postfix-Version (dh i++) Wird der Wert von i erhöht, aber der Wert des Ausdrucks ist der rsprüngliche Wert von i.

Lassen Sie uns den folgenden Code Zeile für Zeile analysieren:

int i = 10;   // (1)
int j = ++i;  // (2)
int k = i++;  // (3)

1. i ist auf 10 gesetzt (einfach).
2. Zwei Dinge in dieser Zeile:
   • i wird auf 11 erhöht.
   • Der neue Wert von i wird in j kopiert. Also ist j jetzt gleich 11.
3. Zwei Dinge auch in dieser Zeile:
   • i wird auf 12 erhöht.
   • Der Original Wert von i (das ist 11) Wird in k kopiert. Also ist k jetzt gleich 11.

Nachdem der Code ausgeführt wurde, ist i 12, aber sowohl j als auch k sind 11.

Das gleiche gilt für Postfix- und Präfix-Versionen von --.

Präfix:

int a=0;

int b=++a;          // b=1,a=1 

vor der Zuweisung wird der Wert von inkrementiert.

Postfix:

int a=0;
int b=a++;  // a=1,b=0 

zuerst den Wert von 'a' zu 'b' zuweisen, dann den Wert von 'a' erhöhen

Die Funktion wird zurückgegeben, bevor i erhöht wird, da Sie einen Postfix-Operator (++) verwenden. In jedem Fall ist das Inkrement von i nicht global - nur für die jeweilige Funktion. Wenn Sie einen Vorfixierungsoperator verwendet hätten, wäre dieser 11 Und würde dann auf 10 Dekrementiert.

Sie geben also i als 10 zurück und dekrementieren es in der Funktion printf, die 9 Und nicht 10 Anzeigt, wie Sie denken.

Tatsächlich gibt return (i++) nur 10 zurück.

Die Operatoren ++ und - können mit unterschiedlichen Effekten vor oder nach der Variablen platziert werden. Wenn sie vorher sind, werden sie verarbeitet und zurückgegeben und im Wesentlichen wie (i-1) oder (i + 1) behandelt. Wenn Sie jedoch das ++ oder - nach dem i einfügen, erfolgt die Rückgabe im Wesentlichen

return i;
i + 1;

Es wird also 10 zurückgegeben und niemals inkrementiert.

Das Postfix-Inkrement ++ Erhöht den Wert seines Operanden erst, nachdem es ausgewertet wurde. Der Wert von i++ Ist i.

Das Präfixdekrement erhöht den Wert seines Operanden vor es wurde ausgewertet. Der Wert von --i Ist i - 1.

Das Präfix Inkrement/Dekrement ändert den Wert, bevor der Ausdruck ausgewertet wird. Postfix Inkrement/Dekrement ändert den Wert danach.

In Ihrem Fall gibt fun(10) also 10 zurück, und beim Drucken von --i Wird i - 1 Ausgegeben, also 9.

i ++ ist Postinkrement. Die Inkrementierung erfolgt nach Rückgabe des Wertes.

Es gibt zwei Beispiele, die den Unterschied verdeutlichen

int a , b , c = 0 ; 
a = ++c ; 
b = c++ ;
printf (" %d %d %d " , a , b , c++);

• Hier hat c den Wert 0 c Inkrement um 1, dann weisen Sie dem Wert von a = 1 Und dem Wert von c = 1 Den Wert 1 zu.

• nächste Anweisung Assiagn Wert von c = 1 bis b, dann Inkrementieren von c um 1, so dass Wert von b = 1 und Wert von c = 2

• in der Anweisung printf haben wir c++. Dies bedeutet, dass der Originalwert von c, der 2 ist, gedruckt wird und dann c um 1 erhöht wird. In der Anweisung printf wird also 1 1 2 und ausgegeben Wert von c ist jetzt 3

sie können http://pythontutor.com/c.html verwenden

int a , b , c = 0 ; 
a = ++c ; 
b = c++ ;
printf (" %d %d %d " , a , b , ++c);

• Hier in printf erhöht die Anweisung ++c Zuerst den Wert von c um 1 und weist dann c den neuen Wert 3 zu, sodass die printf-Anweisung 1 1 3 Ausgibt.

Dies hängt mit der Funktionsweise des Post-Inkrement-Operators zusammen. Es gibt den Wert von i zurück und erhöht dann den Wert.

Beachten Sie zunächst, dass der Funktionsparameter i und die Variable i in main() zwei verschiedene Variablen sind. Ich denke, das ist für die gegenwärtige Diskussion nicht so wichtig, aber es ist wichtig zu wissen.

Zweitens verwenden Sie den Nachinkrementierungsoperator in fun(). Das heißt, das Ergebnis des Ausdrucks ist der Wert vori wird inkrementiert; Der Endwert 11 von i wird einfach verworfen, und die Funktion gibt 10 zurück. Der Variablen i, die wiederum eine andere Variable ist, wird der Wert 10 zugewiesen, den Sie dekrementieren, um ihn zu erhalten 9.

Tatsächlich geschieht Folgendes, wenn Sie Postfix verwenden, d. H. I ++. Der Anfangswert von i wird eher für die Rückgabe als für die inkrementierte verwendet. Danach wird der Wert von i um 1 erhöht. Dies geschieht mit jeder Anweisung, die i ++ verwendet, d. H. Der erste Anfangswert von i wird im Ausdruck verwendet und dann inkrementiert.

Und genau das Gegenteil passiert im Präfix. Wenn Sie ++ i zurückgegeben hätten, wird der inkrementierte Wert, d. H. 11, zurückgegeben, da zuerst 1 hinzugefügt und dann zurückgegeben wird.

Erklärung:

Schritt 1:int fun(int); Hier deklarieren wir den Prototyp der Funktion fun().

Schritt 2:int i = fun(10); Die Variable i wird als Integer-Typ deklariert und das Ergebnis der fun(10) wird in der Variablen i gespeichert. .

Schritt 3:int fun(int i){ return (i++); } Innerhalb von fun() geben wir einen Wert return(i++) zurück. Es wird 10 Zurückgegeben. weil i++ der Post-Inkrement-Operator ist.

Schritt 4: Dann wird der Steuerung wieder die Hauptfunktion und dem Wert 10 Die Variable i zugewiesen.

Schritt 5:printf("%d\n", --i); Hier bezeichnet --i Die Vorinkrementierung. Daher wird der Wert 9 Ausgegeben.

fun (10) gibt 10 zurück. Wenn Sie möchten, dass es 11 zurückgibt, müssen Sie ++ i anstelle von i ++ verwenden.

int fun(int i)
{
    return ++i;
}