Master-C-Inkrementierungs- und Dekrementierungsoperatoren:Verwendung und Best Practices

C – Inkrementierungs- und Dekrementierungsoperatoren

Der Inkrementoperator (++) erhöht den Wert einer Variablen um 1, während der Dekrementoperator (--) den Wert dekrementiert.

Inkrement- und Dekrementoperatoren werden häufig beim Aufbau von Zählschleifen in C (mit der for-Schleife) verwendet. Sie finden auch Anwendung beim Durchlaufen von Array- und Zeigerarithmetik.

Die Operatoren ++ und -- sind unär und können als Präfix oder Posfix für eine Variable verwendet werden.

Beispiel für Inkrementierungs- und Dekrementierungsoperatoren

Das folgende Beispiel enthält mehrere Anweisungen, die die Verwendung von Inkrement- und Dekrementoperatoren mit unterschiedlichen Variationen demonstrieren −

#include <stdio.h>
int main() {
 int a = 5, b = 5, c = 5, d = 5;
 
 a++; // postfix increment
 ++b; // prefix increment
 c--; // postfix decrement
 --d; // prefix decrement
 printf("a = %d\n", a);
 printf("b = %d\n", b);
 printf("c = %d\n", c);
 printf("d = %d\n", d);
 return 0;
}

Ausgabe

Wenn Sie diesen Code ausführen, wird die folgende Ausgabe erzeugt:

a = 6
b = 6
c = 4
d = 4

Beispielerklärung

Mit anderen Worten:„a++“ hat die gleiche Wirkung wie „++a“, da beide Ausdrücke den Wert der Variablen „a“ um 1 erhöhen. Ebenso hat „a--“ die gleiche Wirkung wie „--a“.

Der Ausdruck „a++;“ kann als Äquivalent der Aussage „a =a + 1;“ behandelt werden. Hier addiert der rechte Ausdruck 1 zu „a“ und das Ergebnis wird wieder 1 zugewiesen, wodurch der Wert von „a“ um 1 erhöht wird.

Ebenso „b--;“ ist äquivalent zu „b =b 1;“.

Typen von Inkrementoperatoren

Es gibt zwei Arten von Inkrementoperatoren – Pre-Inkrementoperatoren und Inkrement posten .

Vor-(Präfix-)Inkrementoperator

In einem Ausdruck erhöht der Vorinkrementoperator den Wert einer Variablen um 1, bevor der Wert der Variablen verwendet wird.

Syntax

++variable_name;

Beispiel

Im folgenden Beispiel verwenden wir einen Vorinkrementoperator, bei dem der Wert von „x“ um 1 erhöht wird und der erhöhte Wert dann im Ausdruck verwendet wird.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 10 + ++x;
 printf("x = %d, y = %d\n", x, y);
 return 0;
}

Wenn Sie diesen Code ausführen, wird die folgende Ausgabe erzeugt:

x = 11, y = 21

Post (Postfix) Inkrementoperator

In einem Ausdruck erhöht der Post-Inkrement-Operator den Wert einer Variablen um 1, nachdem der Wert der Variablen verwendet wurde.

Syntax

variable_name++;

Beispiel

Im folgenden Beispiel verwenden wir den Post-Inkrement-Operator, wobei der Wert „x“ im Ausdruck verwendet und dann um 1 erhöht wird.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 10 + x++;
 printf("x = %d, y = %d\n", x, y);
 return 0;
}

Wenn Sie diesen Code ausführen, wird die folgende Ausgabe erzeugt:

x = 11, y = 20

Typen von Dekrementoperatoren

Es gibt zwei Arten von Dekrementierungsoperatoren – Pre-Dekrementieren und Post-Dekrement .

Vor-(Präfix-)Dekrementierungsoperator

In einem Ausdruck verringert der Vordekrementierungsoperator den Wert einer Variablen um 1, bevor der Wert der Variablen verwendet wird.

Syntax

--variable_name;

Beispiel

Im folgenden Beispiel verwenden wir einen Vordekrementierungsoperator, bei dem der Wert von „x“ um 1 verringert wird und der verringerte Wert dann im Ausdruck verwendet wird.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 10 + --x;
 printf("x = %d, y = %d\n", x, y);
 return 0;
}

Wenn Sie diesen Code ausführen, wird die folgende Ausgabe erzeugt:

x = 9, y = 19

Post (Postfix)-Dekrementoperator

In einem Ausdruck verringert der Post-Dekrement-Operator den Wert einer Variablen um 1, nachdem der Wert der Variablen verwendet wurde.

Syntax

variable_name--;

Beispiel

Im folgenden Beispiel verwenden wir den Post-Dekrement-Operator, wobei der Wert „x“ im Ausdruck verwendet und dann um 1 verringert wird.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 10 + x--;
 printf("x = %d, y = %d\n", x, y);
 return 0;
}

Wenn Sie diesen Code ausführen, wird die folgende Ausgabe erzeugt:

x = 9, y = 20

Weitere Beispiele für Inkrementierungs- und Dekrementierungsoperatoren

Beispiel 1

Das folgende Beispiel verdeutlicht die Verwendung von Präfix/Postfix-Inkrement/Dekrement −

#include <stdio.h>
int main(){
 char a = 'a', b = 'M';
 int x = 5, y = 23;
 printf("a: %c b: %c\n", a, b);
 
 a++;
 printf("postfix increment a: %c\n", a);
 
 ++b;
 printf("prefix increment b: %c\n", b);
 printf("x: %d y: %d\n", x, y);
 
 x--;
 printf("postfix decrement x : %d\n", x);
 
 --y;
 printf("prefix decrement y : %d\n", y);
 return 0;
}

Ausgabe

Wenn Sie diesen Code ausführen, wird die folgende Ausgabe erzeugt:

a: a b: M
postfix increment a: b
prefix increment b: N
x: 5 y: 23
postfix decrement x: 4
prefix decrement y: 22

Das obige Beispiel zeigt, dass sowohl der Präfix- als auch der Postfix-Operator die gleiche Wirkung auf den Wert der Operandenvariablen haben. Wenn diese „++“- oder „--“-Operatoren jedoch zusammen mit den anderen Operatoren in einem Ausdruck erscheinen, verhalten sie sich anders.

Beispiel 2

Im folgenden Code sind die Anfangswerte der Variablen „a“ und „b“ gleich, aber die Funktion printf() zeigt unterschiedliche Werte an −

#include <stdio.h>
int main(){
 int x = 5, y = 5;
 printf("x: %d y: %d\n", x,y);
 printf("postfix increment x: %d\n", x++);
 printf("prefix increment y: %d\n", ++y);
 return 0;
}

Ausgabe

Führen Sie den Code aus und überprüfen Sie seine Ausgabe −

x: 5 y: 5
postfix increment x: 5
prefix increment y: 6

Im ersten Fall gibt die Funktion printf() den Wert von „x“ aus und erhöht dann seinen Wert. Im zweiten Fall wird zuerst der Inkrementoperator ausgeführt, die Funktion printf() verwendet den inkrementierten Wert zum Drucken.

Operatorpriorität von Inkrementierungs- und Dekrementierungsoperatoren

Es gibt eine Reihe von Operatoren in C. Wenn mehrere Operatoren in einem Ausdruck verwendet werden, werden sie entsprechend ihrer Rangfolge ausgeführt. Inkrement- und Dekrementoperatoren verhalten sich unterschiedlich, wenn sie zusammen mit anderen Operatoren verwendet werden.

Wenn ein Ausdruck neben anderen Operatoren aus Inkrementierungs- oder Dekrementierungsoperatoren besteht, werden zuerst die Inkrementierungs- und Dekrementierungsoperationen ausgeführt. Postfix-Inkrementierungs- und Dekrementierungsoperatoren haben eine höhere Priorität als Präfix-Inkrementierungs- und Dekrementierungsoperatoren.

Lesen Sie auch: Operatorpriorität in C

Beispiel 1

Schauen Sie sich das folgende Beispiel an −

#include <stdio.h>
int main(){
 int x = 5, z;
 printf("x: %d \n", x);
 z = x++;
 printf("x: %d z: %d\n", x, z);
 return 0;
}

Ausgabe

Führen Sie den Code aus und überprüfen Sie seine Ausgabe −

x: 5 
x: 6 z: 5

Da „x++“ den Wert von „x“ auf 6 erhöht, würden Sie erwarten, dass „z“ ebenfalls 6 ist. Das Ergebnis zeigt jedoch „z“ als 5 an. Dies liegt daran, dass der Zuweisungsoperator eine höhere Priorität gegenüber dem Postfix-Inkrementoperator hat. Daher wird der vorhandene Wert von „x“ „z“ zugewiesen, bevor „x“ erhöht wird.

Beispiel 2

Schauen Sie sich unten ein weiteres Beispiel an −

#include <stdio.h>
int main(){
 int x = 5, y = 5, z;
 printf("x: %d y: %d\n", x,y);
 z = ++y;
 printf("y: %d z: %d\n", y ,z);
 return 0;
}

Ausgabe

Wenn Sie diesen Code ausführen, wird die folgende Ausgabe erzeugt:

y: 5
y: 6 z: 6

Das Ergebnis kann verwirrend sein, da sowohl der Wert von „y“ als auch von „z“ jetzt 6 beträgt. Der Grund dafür ist, dass der Präfix-Inkrementoperator eine höhere Priorität hat als der Zuweisungsoperator. Daher wird „y“ zuerst inkrementiert und dann wird sein neuer Wert „z“ zugewiesen.

Auch die Assoziativität der Operatoren spielt eine wichtige Rolle. Bei Inkrement- und Dekrementoperatoren erfolgt die Assoziativität von links nach rechts. Wenn also in einem einzelnen Ausdruck mehrere Inkrementierungs- oder Dekrementierungsoperatoren vorhanden sind, wird der ganz linke Operator zuerst ausgeführt und dann nach rechts verschoben.

Beispiel 3

In diesem Beispiel enthält der Zuweisungsausdruck sowohl den Präfix- als auch den Postfix-Operator.

#include <stdio.h>
int main(){
 int x = 5, y = 5, z;
 z = x++ + ++y;
 printf("x: %d y: %d z: %d\n", x,y,z);
 return 0;
}

Ausgabe

Führen Sie den Code aus und überprüfen Sie seine Ausgabe −

x: 6 y:6 z: 11

In diesem Beispiel ist die erste auszuführende Operation „y++“ („y“ wird zu 6). Zweitens addiert der „+“-Operator „x“ (das ist 5) und „y“, das Ergebnis wird „z“ als 11 zugewiesen, und dann erhöht „x++“ „x“ auf 6.

Verwendung des Inkrementoperators in einer Schleife

In C lautet die am häufigsten verwendete Syntax einer for-Schleife wie folgt:−

for (init_val; final_val; increment) {
 statement(s);
}

Beispiel

Der Schleifenkörper wird für alle Werte einer Variablen zwischen dem Anfangs- und dem Endwert ausgeführt und nach jeder Runde erhöht.

#include <stdio.h>
int main(){
 int x;
 for (x = 1; x <= 5; x++){
 printf("x: %d\n", x);
 }
 
 return 0;
}

Ausgabe

Wenn Sie diesen Code ausführen, wird die folgende Ausgabe erzeugt:

x: 1
x: 2
x: 3
x: 4
x: 5