C++-Operatoren: arithmetisch, Vergleich, logisch und mehr

Was Operatoren tun

Ein Operator ist ein Symbol, das eine Aktion auf einem oder mehreren Werten ausführt, den sogenannten Operanden. Einen hast du bereits benutzt: das =, das einen Wert an eine Variable bindet. C++ bringt einen reichhaltigen Satz an Operatoren für Mathematik, Vergleiche, Logik und Bitmanipulation mit - sowie ein paar scharfe Kanten, über die Einsteiger stolpern.

Auf der vorherigen Seite hast du gesehen, wie const einen Wert festschreibt. Operatoren sind die Art und Weise, wie du die Werte berechnest, die du speicherst - ob konstant oder nicht. Gehen wir die Familien durch, die du jeden Tag verwenden wirst.

Arithmetische Operatoren

Die fünf arithmetischen Operatoren sind +, -, *, / und % (Modulo, der Rest einer Division):

#include <iostream>
using namespace std;

int main() {
    int a = 17, b = 5;

    cout << "sum:       " << a + b << "\n";
    cout << "difference: " << a - b << "\n";
    cout << "product:    " << a * b << "\n";
    cout << "quotient:   " << a / b << "\n";
    cout << "remainder:  " << a % b << "\n";

    return 0;
}

Der große Fallstrick steckt in diesem Quotienten. 17 / 5 gibt 3 aus, nicht 3.4. Wenn beide Operanden Ganzzahlen sind, führt / eine Ganzzahldivision durch und wirft den Nachkommateil weg - es schneidet Richtung null ab, es rundet nicht. Wenn du einen echten Bruch willst, muss mindestens ein Operand ein Gleitkommawert sein:

#include <iostream>
using namespace std;

int main() {
    int a = 17, b = 5;

    cout << a / b << "\n";          // 3  -> Ganzzahldivision
    cout << 17.0 / 5 << "\n";       // 3.4 -> 17.0 ist ein double
    cout << (double)a / b << "\n";  // 3.4 -> wandle zuerst einen Operanden um

    return 0;
}

Der %-Operator funktioniert nur mit Ganzzahlen. % auf einem double zu verwenden ist ein Kompilierfehler - nutze std::fmod aus <cmath> für Gleitkomma-Reste.

Zuweisung und zusammengesetzte Operatoren

Ein einzelnes = weist zu; es vergleicht nicht. C++ bietet dir zusammengesetzte Formen, die eine Operation mit der Zuweisung kombinieren, damit du den Variablennamen nicht wiederholen musst:

#include <iostream>
using namespace std;

int main() {
    int score = 10;

    score += 5;   // score = score + 5  -> 15
    score -= 3;   // 12
    score *= 2;   // 24
    score /= 4;   // 6
    score %= 4;   // 2

    cout << score << "\n";   // 2
    return 0;
}

Ein klassischer, schmerzhafter Fehler ist, in einer Bedingung = zu schreiben, wo du == meintest. if (x = 0) weist x den Wert 0 zu und prüft dann das Ergebnis (das falsch ist), anstatt zu vergleichen. Moderne Compiler warnen davor, wenn du Warnungen einschaltest - lass -Wall aktiviert und nimm die Warnung ernst.

Vergleichsoperatoren

Vergleichsoperatoren stellen eine Ja/Nein-Frage und liefern einen bool (true oder false):

#include <iostream>
using namespace std;

int main() {
    int x = 7, y = 10;

    cout << (x == y) << "\n";  // 0  (false)
    cout << (x != y) << "\n";  // 1  (true)
    cout << (x <  y) << "\n";  // 1
    cout << (x >= 7) << "\n";  // 1

    cout << boolalpha;          // gibt true/false statt 1/0 aus
    cout << (x < y) << "\n";    // true
    return 0;
}

Standardmäßig gibt cout einen bool als 1 oder 0 aus. Schreibe boolalpha einmal in den Stream, und er wechselt für den Rest dieses Streams zu den Wörtern true/false.

Eine subtile Falle: Verkette keine Vergleiche wie 1 < x < 10. Das wird als (1 < x) < 10 ausgewertet - der erste Vergleich liefert einen bool (0 oder 1), der dann mit 10 verglichen wird, sodass das Ganze fast immer true ist. Schreibe stattdessen 1 < x && x < 10.

Logische Operatoren und Kurzschlussauswertung

&& (und), || (oder) und ! (nicht) verknüpfen boolesche Ausdrücke. Die ersten beiden werten kurzgeschlossen aus: Die Auswertung stoppt, sobald das Ergebnis feststeht.

#include <iostream>
using namespace std;

bool check(const char* label) {
    cout << "checked " << label << "\n";
    return true;
}

int main() {
    // Die rechte Seite von && wird übersprungen, weil die linke false ist:
    if (false && check("A")) {}

    // Die rechte Seite von || wird übersprungen, weil die linke true ist:
    if (true || check("B")) {}

    cout << "done\n";
    return 0;
}

Weder check("A") noch check("B") wird jemals ausgeführt - das ist Kurzschlussauswertung. Sie ist nicht nur eine Optimierung; sie ist ein Werkzeug. Du kannst gefahrlos if (ptr != nullptr && ptr->ready) schreiben, weil der Teil ptr->ready nur erreicht wird, wenn ptr nicht null ist, was das Dereferenzieren eines ungültigen Zeigers vermeidet.

Inkrement und Dekrement

++ addiert eins; -- subtrahiert eins. Jeder hat eine Präfix- und eine Postfix-Form, und der Unterschied zählt, wenn du das Ergebnis verwendest:

#include <iostream>
using namespace std;

int main() {
    int i = 5;
    cout << ++i << "\n";  // erhöht auf 6, gibt dann 6 aus (Prä)

    int j = 5;
    cout << j++ << "\n";  // gibt 5 aus, ERHÖHT DANN auf 6 (Post)
    cout << j   << "\n";  // 6

    return 0;
}

Wenn du nur den Seiteneffekt willst (etwa in einer for-Schleife), bevorzuge ++i. Für ein einfaches int ist es identisch, aber bei schwereren Typen wie Iteratoren muss das Postinkrement zuerst den alten Wert kopieren, was verschwendete Arbeit ist.

Noch eine Warnung: Ändere dieselbe Variable nicht zweimal in einem einzigen Ausdruck, etwa i = i++ + 1; oder arr[i] = i++;. Die Reihenfolge dieser Aktualisierungen ist nicht festgelegt und das Ergebnis ist undefiniertes Verhalten. Beschränke jede Variable auf eine einzige Änderung pro Anweisung.

Bit-Operatoren und Vorrang

Für Low-Level-Arbeit gibt es Bit-Operatoren: & (und), | (oder), ^ (xor), ~ (nicht) sowie die Verschiebungen << und >>.

#include <iostream>
using namespace std;

int main() {
    unsigned int flags = 0b0101;   // Binärliteral: 5

    cout << (flags & 0b0001) << "\n";  // 1  -> Bit 0 ist gesetzt
    cout << (flags | 0b0010) << "\n";  // 7  -> setzt Bit 1
    cout << (flags ^ 0b0101) << "\n";  // 0  -> xor mit sich selbst
    cout << (flags << 1)      << "\n"; // 10 -> Linksverschiebung, verdoppelt es

    return 0;
}

Achtung: << und >> sind auch die Stream-Operatoren auf cout. Innerhalb einer cout-Zeile brauchst du um eine Bitverschiebung normalerweise Klammern, sonst liest der Compiler sie als Stream-Einfügung.

Zuletzt entscheidet der Vorrang, was zuerst bindet, wenn du Operatoren mischst. * und / binden stärker als + und -, genau wie in der Mathematik, also ist 2 + 3 * 4 gleich 14. Vergleiche binden schwächer als Arithmetik, und die logischen &&/|| noch schwächer. Im Zweifel die ganze Tabelle nicht auswendig lernen - setze Klammern. (a + b) * c ist klarer, als sich darauf zu verlassen, dass der Leser die Regeln kennt.

Als Nächstes: Typumwandlung

Du hast oben gesehen, dass (double)a / b eine Ganzzahl in eine Gleitkommadivision gezwungen hat. Das ist eine Umwandlung (Cast) - ein Wert wird bewusst von einem Typ in einen anderen umgewandelt. Auf der nächsten Seite behandeln wir die Umwandlungswerkzeuge von C++, von impliziten Promotions bis static_cast, und wann welches sicher ist.