C++ Tutorial

Grundrechenoperationen, Komma-Operator

Grundrechenoperationen

Für Berechnungen stehen die Rechenoperationen Addition +, Subtraktion -, Multiplikation * und Division / zur Verfügung. Diese Operationen sind sowohl auf Integer- wie auf Gleitkomma-Daten anwendbar.

Wird eine Division mit zwei Integer-Daten durchgeführt, ist das Ergebnis ebenfalls ein Integer-Datum. Es erfolgt keine Rundung des Ergebnisses. Soll das Ergebnis als Gleitkomma-Datum weiterverarbeitet werden, ist mindestens einer der Operanden vor der Division in ein Gleitkomma-Datum zu konvertieren. Mehr dazu bei den Typkonvertierungen.

Für Integer-Daten steht ferner der Modulo-Operator % (das Prozentzeichen) zur Verfügung. Er berechnet den Rest einer Division von zwei Integer-Daten (siehe Beispiel).

1:	#include <iostream>
2:	#include <print>
3:	
4:	// Zwei Integer-Variablen definieren
5:	auto var1=10, var2=3;
6:	
7:	int main ()
8:	{
9:     // Division zweier Integer
10:    auto result = var1/var2;
11:    std::println("10/3={}", result);
12:    // Modulo zweier Integer
13:    result = var1%var2;
14:    std::println("10%3={}\n", result);
15:	}

10/3=3
10%3=1

Bei allen Operationen gilt: Punkt- vor Strichrechnung, d.h. Multiplikation, Division und Modulo vor Addition und Subtraktion. Diese Reihenfolge kann durch Setzen von Klammern geändert werden.

Kurzschreibweisen

C++ stellt eine Reihe von Kurzschreibweisen für häufig benötigte Rechenoperationen bereit.

Kurzschr.

Bedeutung

x++

Erhöht x um 1 nach dessen Auswertung

++x

Erhöht x um 1 vor dessen Auswertung

x--

Vermindert x um 1 nach dessen Auswertung

--x

Vermindert x um 1 vor dessen Auswertung

x += y

Addiert y zu x (x = x + y)

x -= y

Subtrahiert y von x (x = x - y)

x *= y

Multipliziert x mit y (x = x * y)

x /= y

Dividiert x durch y (x = x / y)

x %= y

Weist x den Rest der Division x/y zu (x = x % y)

1:	auto X = 10; // Initialisierung der Variablen
2:	auto Y = 2;
3:	
4:	X++;      // X = X+1 => 11
5:	
6:	Y = X++;  // Y = X => 11 und dann X = X+1 => 12
7:	
8:	Y = ++X;  // X = X+1 => 13 und dann Y = X => 13
9:	
10:	X += Y;  // X = X+Y => 13+13 = 26
11:	
12:	X %= 5;  // X = X%5 => 26%5 = 1
13:	
14:	X += (--Y * 2);   // Y = Y-1 => 12, dann X = X+12*2 => 1+24

Beachten Sie den Unterschied in den Berechnungen zwischen X++ und ++X bzw. X-- und --X (Zeilen 6, 8 und 14).

Komma-Operator

Mithilfe des Komma-Operators können an Stellen, an den sonst nur ein Ausdruck steht, mehrere Ausdrücke angegeben werden. Er hat folgende Syntax:

AUSDRUCK1, AUSDRUCK2

Zuerst wird AUSDRUCK1 ausgewertet und dessen Ergebnis dann verworfen. Anschließend wird AUSDRUCK2 ausgewertet und dessen Ergebnis zurückgegeben. Damit lässt sich zwar das nachfolgende Programm fehlerfrei übersetzen, jedoch mag das Ergebnis der Berechnung überraschen.

1:	// print-Datei einbinden
2:	#include <print>
3:	
4:	// main() Funktion
5:	int main ()
6:	{
7:     auto val1 = 1, val2 = 2;
8:     decltype(val1) result;
9:     result = val1+1, val2+1;
10:    std::println("{}",result);
11:    result = (val1+1, val2+1);
12:    std::println("{}",result);
13:	}

2
3

Die println-Anweisung in der Zeile 10 wird den Wert 2 ausgeben und die in Zeile 12 den Wert 3. Der Grund ist, dass der Zuweisungsoperator eine höhere Priorität besitzt als der Komma-Operator, die Klammer aber wiederum eine höhere Priorität als die Zuweisung.

Hier folgen in der Offline-Version die Übungen.