C Increment- und Decrement-Operatoren meistern: Nutzung & Best Practices

C - Increment- und Decrement-Operatoren

Der Increment-Operator (++) erhöht den Wert einer Variable um 1, während der Decrement-Operator (--) den Wert verringert.

Increment- und Decrement-Operatoren werden häufig beim Aufbau von gezählten Schleifen in C (mit der for-Schleife) verwendet. Sie finden auch Anwendung bei der Traversierung von Arrays und Zeigerarithmetik.

Die Operatoren ++ und -- sind unär und können als Präfix oder Postfix zu einer Variable verwendet werden.

Beispiel für Increment- und Decrement-Operatoren

Das folgende Beispiel enthält mehrere Statements, die die Verwendung der Increment- und Decrement-Operatoren mit verschiedenen 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

Beim Ausführen wird folgende Ausgabe produziert:

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

Beispiel-Erklärung

Mit anderen Worten: a++ hat denselben Effekt wie ++a, da beide Ausdrücke den Wert der Variable a um 1 erhöhen. Entsprechend hat a-- denselben Effekt wie --a.

Der Ausdruck a++; kann als äquivalent zum Statement a = a + 1; betrachtet werden. Hier addiert der rechte Ausdruck 1 zu a und weist das Ergebnis wieder a zu, wodurch der Wert von a um 1 inkrementiert wird.

Analog ist b--; äquivalent zu b = b - 1;.

Arten des Increment-Operators

Es gibt zwei Arten von Increment-Operatoren – Pre-Increment und Post-Increment.

Pre-Increment-Operator (Präfix)

In einem Ausdruck erhöht der Pre-Increment-Operator den Wert einer Variable um 1, bevor der Wert der Variable verwendet wird.

Syntax

++variable_name;

Beispiel

Im folgenden Beispiel nutzen wir einen Pre-Increment-Operator: Der Wert von x wird um 1 erhöht, und dann wird der erhöhte Wert im Ausdruck verwendet.

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

Ausgabe beim Ausführen:

x = 11, y = 21

Post-Increment-Operator (Postfix)

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

Syntax

variable_name++;

Beispiel

Im folgenden Beispiel nutzen wir einen Post-Increment-Operator: Der Wert von x wird im Ausdruck verwendet und dann um 1 erhöht.

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

Ausgabe beim Ausführen:

x = 11, y = 20

Arten des Decrement-Operators

Es gibt zwei Arten von Decrement-Operatoren – Pre-Decrement und Post-Decrement.

Pre-Decrement-Operator (Präfix)

In einem Ausdruck verringert der Pre-Decrement-Operator den Wert einer Variable um 1, bevor der Wert der Variable verwendet wird.

Syntax

--variable_name;

Beispiel

Im folgenden Beispiel nutzen wir einen Pre-Decrement-Operator: Der Wert von x wird um 1 verringert, und dann wird der verringerte Wert im Ausdruck verwendet.

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

Ausgabe beim Ausführen:

x = 9, y = 19

Post-Decrement-Operator (Postfix)

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

Syntax

variable_name--;

Beispiel

Im folgenden Beispiel nutzen wir einen Post-Decrement-Operator: Der Wert von x wird im Ausdruck verwendet und dann um 1 verringert.

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

Ausgabe beim Ausführen:

x = 9, y = 20

Weitere Beispiele für Increment- und Decrement-Operatoren

Beispiel 1

Das folgende Beispiel verdeutlicht die Nutzung von Präfix-/Postfix-Increment/Decrement:

#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

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 Präfix- wie Postfix-Operatoren denselben Effekt auf den Wert der Operanden-Variable haben. Wenn diese ++ oder -- Operatoren jedoch zusammen mit anderen Operatoren in einem Ausdruck auftreten, verhalten sie sich unterschiedlich.

Beispiel 2

Im folgenden Code haben die Variablen a und b dieselben Initialwerte, aber printf() zeigt unterschiedliche Werte:

#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

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

Im ersten Fall gibt printf() den Wert von x aus und inkrementiert ihn dann. Im zweiten Fall wird der Increment-Operator zuerst ausgeführt, printf() nutzt den inkrementierten Wert für die Ausgabe.

Operator-Rangfolge (Precedence) von Increment- und Decrement-Operatoren

In C gibt es viele Operatoren. Wenn mehrere Operatoren in einem Ausdruck verwendet werden, werden sie gemäß ihrer Rangfolge ausgeführt. Increment- und Decrement-Operatoren verhalten sich anders, wenn sie zusammen mit anderen Operatoren genutzt werden.

Wenn ein Ausdruck Increment- oder Decrement-Operatoren neben anderen Operatoren enthält, werden die Increment-/Decrement-Operationen zuerst ausgeführt. Postfix-Increment- und -Decrement-Operatoren haben höhere Präzedenz als Präfix-Increment- und -Decrement-Operatoren.

Weiterlesen: Operator Precedence in C

Beispiel 1

Betrachten Sie folgendes Beispiel:

#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

x: 5
x: 6 z: 5

Da x++ den Wert von x auf 6 erhöht, würde man erwarten, dass z ebenfalls 6 ist. Das Ergebnis zeigt jedoch z als 5. Das liegt daran, dass der Zuweisungsoperator eine höhere Präzedenz als der Postfix-Increment-Operator hat. Daher wird der existierende Wert von x an z zugewiesen, bevor x inkrementiert wird.

Beispiel 2

Ein weiteres Beispiel:

#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

y: 5
y: 6 z: 6

Das Ergebnis mag verwirrend sein, da sowohl y als auch z nun 6 sind. Der Grund: Der Präfix-Increment-Operator hat höhere Präzedenz als der Zuweisungsoperator. Daher wird y zuerst inkrementiert und dann sein neuer Wert an z zugewiesen.

Die Assoziativität der Operatoren spielt ebenfalls eine wichtige Rolle. Für Increment- und Decrement-Operatoren ist die Assoziativität von links nach rechts. Deshalb wird, wenn mehrere Increment- oder Decrement-Operatoren in einem einzigen Ausdruck stehen, der linkeste Operator zuerst ausgeführt, dann nach rechts weiter.

Beispiel 3

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

#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

x: 6 y:6 z: 11

In diesem Beispiel ist die erste Operation ++y (y wird 6). Zweitens addiert der +-Operator x (das ist 5) und y, das Ergebnis wird z als 11 zugewiesen, und dann inkrementiert x++ x auf 6.

Increment-Operator in Schleifen verwenden

In C ist die gängigste Syntax einer for-Schleife wie folgt:

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

Beispiel

Der Schleifenkörper wird für alle Werte einer Variable zwischen Initial- und Endwert ausgeführt, inkrementiert nach jeder Runde.

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

Ausgabe

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