Die switch-Anweisung in C++: cases, Fall-Through und break

Wofür switch da ist

Ein switch vergleicht einen Wert mit einer Liste fester Optionen und führt den passenden Zweig aus. Wenn du dich dabei ertappst, eine lange if/else if-Kette zu schreiben, die immer wieder dieselbe Variable gegen verschiedene Konstanten prüft, drückt ein switch diese Absicht klarer aus – und übersetzt sich oft zu einer schnelleren Sprungtabelle.

Es führt nur Gleichheitsprüfungen gegen Konstanten zur Übersetzungszeit auf einem ganzzahlartigen Wert durch. Es kann keine Bereiche prüfen, keine Zeichenketten vergleichen und keine Bedingungen kombinieren. Für all das bleib bei if/else.

Das einfache switch

Du gibst switch einen Wert und listest dann case-Marken für die Werte auf, die dich interessieren. Jeder Zweig endet mit break:

#include <iostream>
using namespace std;

int main() {
    int day = 3;

    switch (day) {
        case 1:
            cout << "Monday" << endl;
            break;
        case 2:
            cout << "Tuesday" << endl;
            break;
        case 3:
            cout << "Wednesday" << endl;
            break;
        default:
            cout << "Some other day" << endl;
            break;
    }

    return 0;
}

Der Wert 3 passt zu case 3:, also wird "Wednesday" ausgegeben und break springt aus dem switch heraus. Der default-Zweig ist der Auffangfall – er läuft, wenn kein case passt. Er ist optional, aber füge ihn ein, sofern du dir nicht sicher bist, dass jeder Wert behandelt wird.

Beachte, dass case-Marken bloße Konstanten gefolgt von einem Doppelpunkt sind, keine Bedingungen. Du schreibst case 3:, niemals case day == 3:.

break und Fall-Through

Das ist der wichtigste Fallstrick von switch in C++. Nachdem ein case passt, hält die Ausführung nicht beim nächsten case an – sie läuft geradeaus weiter, bis sie auf ein break oder die schließende Klammer trifft. Sieh dir an, was passiert, wenn die break-Anweisungen fehlen:

#include <iostream>
using namespace std;

int main() {
    int level = 1;

    switch (level) {
        case 1:
            cout << "one" << endl;
        case 2:
            cout << "two" << endl;
        case 3:
            cout << "three" << endl;
        default:
            cout << "done" << endl;
    }

    return 0;
}

Du könntest nur "one" erwarten. Stattdessen werden alle vier Zeilen ausgegeben: Der Treffer bei case 1: steigt dort in den switch ein und fällt dann durch alle darunterliegenden Marken hindurch. Füge nach jedem Zweig ein break; ein, und du erhältst die eine gewünschte Zeile. Ein vergessenes break ist die klassische Ursache für Fehler der Art „Warum führt mein switch zu viel Code aus?“.

Absichtliches Fall-Through, um Fälle zu gruppieren

Fall-Through ist nicht immer ein Fehler – es ist die idiomatische Art, mehrere Fälle einen gemeinsamen Rumpf teilen zu lassen. Lass die Fälle leer (keine Anweisungen, kein break), dann fließen sie alle in den nächsten Block:

#include <iostream>
using namespace std;

int main() {
    char grade = 'B';

    switch (grade) {
        case 'A':
        case 'B':
        case 'C':
            cout << "Pass" << endl;
            break;
        case 'D':
        case 'F':
            cout << "Fail" << endl;
            break;
        default:
            cout << "Invalid grade" << endl;
    }

    return 0;
}

'A', 'B' und 'C' landen alle auf derselben "Pass"-Zeile, weil die ersten beiden Fälle leer sind und in den dritten durchfallen. Das ist sauber und beabsichtigt. Wenn du tatsächlich nach dem Ausführen von etwas Code durchfallen willst, dokumentiere es mit einem Kommentar – oder ab C++17 mit dem Attribut [[fallthrough]];, das dem Compiler sagt „ja, das war Absicht“ und Fall-Through-Warnungen verstummen lässt.

switch über Enums

switch passt von Natur aus zu Enums, da ein Enum genau „einer aus einer festen Menge von Werten“ ist. Compiler können dich außerdem warnen, wenn du vergisst, einen der Aufzählungswerte zu behandeln:

#include <iostream>
using namespace std;

enum class Direction { North, East, South, West };

int main() {
    Direction d = Direction::East;

    switch (d) {
        case Direction::North:
            cout << "Heading up" << endl;
            break;
        case Direction::East:
            cout << "Heading right" << endl;
            break;
        case Direction::South:
            cout << "Heading down" << endl;
            break;
        case Direction::West:
            cout << "Heading left" << endl;
            break;
    }

    return 0;
}

Bei einem enum class mit Geltungsbereich musst du jede Marke qualifizieren (Direction::East). Da jeder Aufzählungswert abgedeckt ist, ist kein default nötig – und viele Compiler warnen dich, wenn du später eine fünfte Richtung hinzufügst und ihren Fall vergisst. Diese Compiler-Hilfe ist ein wichtiger Grund, bei Enums switch gegenüber if/else-Ketten vorzuziehen.

Ein Fallstrick: Deklarationen innerhalb eines case

Du kannst keine Variable mit Initialisierer in einem case deklarieren und sie über die anderen Fälle hinweg sichtbar machen, ohne ihr einen Geltungsbereich zu geben. Das ist ein häufiger Übersetzungsfehler:

switch (x) {
    case 1:
        int n = 10;   // Fehler: der Sprung zu case 2 umgeht diese Initialisierung
        cout << n;
        break;
    case 2:
        cout << "two";
        break;
}

Der Compiler lehnt das ab, weil das Hineinfallen in case 2: über die Initialisierung von n hinwegspringen würde, während n noch im Geltungsbereich ist. Die Lösung besteht darin, den case-Rumpf in eigene geschweifte Klammern zu fassen und der Variablen so einen eigenen Block zu geben:

#include <iostream>
using namespace std;

int main() {
    int x = 1;

    switch (x) {
        case 1: {
            int n = 10;   // jetzt auf diesen Block beschränkt – in Ordnung
            cout << n << endl;
            break;
        }
        case 2:
            cout << "two" << endl;
            break;
    }

    return 0;
}

Wann immer ein case seine eigene lokale Variable braucht, gib ihm geschweifte Klammern. Das verhindert auch, dass die Variable in die darunterliegenden Fälle durchsickert.

Als Nächstes: die for-Schleife

switch und if lassen dein Programm einmal auswählen, welcher Code ausgeführt wird. Aber viel Arbeit bedeutet, dasselbe viele Male zu tun: zählen, über eine Liste iterieren, wiederholen, bis sich eine Bedingung ändert. Die for-Schleife ist das Arbeitspferd dafür, und sie ist die nächste Seite.