Übung: Schrittweises Erhöhen und Verringern von Werten

10 Minuten

Abschließend lernen Sie in diesem Modul die grundlegenden Operationen für das schrittweise Erhöhen und Verringern von Werten kennen. Dabei werden besondere Operatoren eingesetzt, die aus unterschiedlichen Zeichen bestehen.

Schrittweises Erhöhen und Verringern

Häufig müssen Sie Werte schrittweise erhöhen und/oder verringern, insbesondere wenn Sie Schleifenlogik oder Code schreiben, die bzw. der mit einer Datenstruktur interagiert.

Der +=-Operator fügt dem Wert auf der linken Seite des Operators den Wert auf der rechten Seite des Operators hinzu und weist ihn zu. Folglich sind die Zeilen zwei und drei im folgenden Codeausschnitt identisch:

int value = 0;     // value is now 0.
value = value + 5; // value is now 5.
value += 5;        // value is now 10.

Der ++-Operator erhöht den Wert der Variable um 1. Folglich sind die Zeilen zwei und drei im folgenden Codeausschnitt identisch:

int value = 0;     // value is now 0.
value = value + 1; // value is now 1.
value++;           // value is now 2.

Diese Techniken können für Subtraktion, Multiplikation u. v. m. verwendet werden. In den folgenden Übungsschritten werden einige davon beschrieben.

Hinweis

Operatoren wie +=, -=, *=, ++ und -- werden auch als zusammengesetzte Zuweisungsoperatoren bezeichnet, da eine bestimmte Operation wie eine Addition ausgeführt und das Ergebnis zusätzlich der Variable zugewiesen wird. Der +=-Operator ist auch unter der Bezeichnung Additionszuweisungsoperator bekannt.

Schreiben von Code, um einen Wert schrittweise zu erhöhen und zu verringern

Wählen Sie den gesamten Code im .NET-Editor aus, und drücken Sie dann ENTF oder die RÜCKTASTE, um den Code zu löschen.

Geben Sie im .NET-Editor den folgenden Code ein:

int value = 1;

value = value + 1;
Console.WriteLine("First increment: " + value);

value += 1;
Console.WriteLine("Second increment: " + value);

value++;
Console.WriteLine("Third increment: " + value);

value = value - 1;
Console.WriteLine("First decrement: " + value);

value -= 1;
Console.WriteLine("Second decrement: " + value);

value--;
Console.WriteLine("Third decrement: " + value);

Führen Sie den Code aus. Die folgende Ausgabe wird angezeigt:

First increment: 2
Second increment: 3
Third increment: 4
First decrement: 3
Second decrement: 2
Third decrement: 1

Hinweis

Im Schritt „Second increment“ (zweites Inkrement) haben Sie value += 1; verwendet. Genauso wäre aber jeder int-Literalwert (oder eine Variable) zum schrittweisen Erhöhen möglich. Das Gleiche gilt für die zweite Dekrementoperation value -= 1;.

Platzieren der Inkrement- und Dekrementoperatoren

Die Inkrement- und Dekrementoperatoren weisen eine interessante Eigenschaft auf: Abhängig von ihrer Position führen sie eine Operation vor oder nach dem Abrufen des zugehörigen Werts durch. Anders ausgedrückt: Wenn Sie dem Wert den Operator voranstellen (wie in ++value), findet die schrittweise Erhöhung statt, bevor der Wert abgerufen wird. Analog dazu erhöht value++ den Wert schrittweise, nachdem dieser abgerufen wurde.

Verwenden des Inkrementoperators vor und nach dem Wert

Löschen Sie den Code aus den vorherigen Schritten, und geben Sie den folgenden Code in den .NET-Editor ein:

int value = 1;
value++;
Console.WriteLine("First: " + value);
Console.WriteLine($"Second: {value++}");
Console.WriteLine("Third: " + value);
Console.WriteLine("Fourth: " + (++value));

Führen Sie den Code aus. Die folgende Ausgabe wird angezeigt:
```
First: 2
Second: 2
Third: 3
Fourth: 4
```

Beachten Sie die folgende Codezeile:

Console.WriteLine($"Second: {value++}");

Diese Zeile umfasst zwei Schritte:

Zuerst wird der aktuelle Wert der Variable value abgerufen und in der Operation für die Zeichenfolgeninterpolation verwendet.
Anschließend wird der Wert schrittweise erhöht.

Durch die nächste Codezeile wird bestätigt, dass der Wert tatsächlich schrittweise erhöht wurde.

Console.WriteLine("Third: " + value);

Beachten Sie im Gegensatz dazu die letzte Codezeile:

Console.WriteLine("Fourth: " + (++value));

Hier wird die Reihenfolge der Operationen umgedreht, da der ++-Operator dem value-Operanden vorangestellt wird.

Zuerst wird der Wert schrittweise erhöht.
Rufen Sie den neuen erhöhten Wert der Variablen value ab, und verwenden Sie ihn im Zeichenfolgenvorgang.

Der Ausdruck (++value) wurde in Klammern eingeschlossen. Dies ist zwar nicht unbedingt notwendig, verbessert aber die Lesbarkeit. Wenn mehrere +-Operatoren nebeneinander stehen, besteht die Gefahr, dass es bei anderen Entwicklern zu Missverständnissen kommt. Derartige stilistische Entscheidungen sind subjektiv. Da Sie den Code nur einmal schreiben, aber immer wieder lesen, sollten Sie die Lesbarkeit priorisieren.

Zusammenfassung

Hier sehen Sie, was Sie bisher über mathematische Operationen in C# gelernt haben:

Verwenden Sie zusammengesetzte Zuweisungsoperatoren wie +=, -=, *=, ++ und --, um eine mathematische Operation wie das schrittweise Erhöhen oder Verringern eines Werts auszuführen und dann das Ergebnis der ursprünglichen Variablen zuzuweisen.
Inkrement- und Dekrementoperatoren führen unterschiedliche Operationen aus, wenn der Operator dem Operanden voran- oder nachgestellt ist.