Instrukcja switch w C++: case, fall-through i break

Do czego służy switch

switch porównuje jedną wartość z listą stałych opcji i wykonuje pasującą gałąź. Jeśli łapiesz się na pisaniu długiego łańcucha if/else if, który w kółko sprawdza tę samą zmienną z różnymi stałymi, switch wyraża ten zamiar czytelniej i często kompiluje się do szybszej tablicy skoków.

Wykonuje wyłącznie sprawdzenia równości ze stałymi znanymi w czasie kompilacji, na wartości typu całkowitoliczbowego. Nie sprawdzi zakresów, nie porówna napisów i nie połączy warunków. W każdym z tych przypadków zostań przy if/else.

Podstawowy switch

Przekazujesz do switch wartość, a potem wypisujesz etykiety case dla interesujących cię wartości. Każda gałąź kończy się instrukcją 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;
}

Wartość 3 pasuje do case 3:, więc wypisuje się "Wednesday", a break wyskakuje z instrukcji switch. Gałąź default łapie wszystko inne: wykonuje się, gdy żaden case nie pasuje. Jest opcjonalna, ale dodawaj ją, chyba że masz pewność, że obsłużono każdą wartość.

Zauważ, że etykiety case to gołe stałe z dwukropkiem, a nie warunki. Piszesz case 3:, nigdy case day == 3:.

break i fall-through

To najważniejsza pułapka instrukcji switch w C++. Po dopasowaniu case wykonanie nie zatrzymuje się na następnym case: biegnie dalej, aż trafi na break albo zamykającą klamrę. Zobacz, co się dzieje, gdy brakuje instrukcji break:

#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;
}

Można by się spodziewać samego "one". Zamiast tego wypisują się wszystkie cztery linie: dopasowanie case 1: wchodzi do instrukcji switch w tym miejscu, a potem przechodzi przez każdą etykietę poniżej. Dodaj break; po każdej gałęzi, a dostaniesz tylko tę jedną linię, o którą chodziło. Brak break to klasyczne źródło błędów typu "dlaczego mój switch wykonuje za dużo kodu?".

Celowe fall-through do grupowania przypadków

Fall-through nie zawsze jest błędem: to idiomatyczny sposób, żeby kilka przypadków dzieliło jedno ciało. Zostaw przypadki puste (bez instrukcji i bez break), a wszystkie przejdą do następnego bloku:

#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' i 'C' trafiają do tej samej linii "Pass", bo dwa pierwsze przypadki są puste i przechodzą do trzeciego. To czysty i zamierzony kod. Gdy naprawdę chcesz przejść dalej po wykonaniu jakiegoś kodu, opisz to komentarzem albo, od C++17, atrybutem [[fallthrough]];, który mówi kompilatorowi "tak, tak miało być" i wycisza ostrzeżenia o fall-through.

switch na typach enum

switch naturalnie współpracuje z typami wyliczeniowymi, bo enum to właśnie "jedna z ustalonego zbioru wartości". Kompilatory potrafią też ostrzec, gdy zapomnisz obsłużyć któryś z enumeratorów:

#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;
}

Przy enum class z zakresem musisz kwalifikować każdą etykietę (Direction::East). Wszystkie enumeratory są obsłużone, więc default nie jest potrzebny, a wiele kompilatorów ostrzeże cię, gdy później dodasz piąty kierunek i zapomnisz o jego przypadku. Ta pomoc kompilatora to ważny powód, by przy typach enum wybierać switch zamiast łańcuchów if/else.

Pułapka: deklaracje wewnątrz case

Nie możesz zadeklarować zmiennej z inicjalizatorem w jednym przypadku i mieć jej widocznej w pozostałych bez nadania jej własnego zakresu. To częsty błąd kompilacji:

switch (x) {
    case 1:
        int n = 10;   // błąd: skok do case 2 pomija tę inicjalizację
        cout << n;
        break;
    case 2:
        cout << "two";
        break;
}

Kompilator to odrzuca, bo wejście do case 2: pominęłoby inicjalizację n, podczas gdy n nadal byłoby w zasięgu. Rozwiązanie to otoczenie ciała przypadku własnymi klamrami, dzięki czemu zmienna dostaje osobny blok:

#include <iostream>
using namespace std;

int main() {
    int x = 1;

    switch (x) {
        case 1: {
            int n = 10;   // teraz ograniczona do tego bloku, wszystko w porządku
            cout << n << endl;
            break;
        }
        case 2:
            cout << "two" << endl;
            break;
    }

    return 0;
}

Gdy case potrzebuje własnej zmiennej lokalnej, daj mu klamry. Dzięki temu zmienna nie wycieka też do przypadków poniżej.

Dalej: pętla for

switch i if pozwalają programowi jednorazowo wybrać, który kod wykonać. Wiele zadań wymaga jednak robienia tego samego wiele razy: liczenia, przechodzenia po liście, powtarzania, aż zmieni się warunek. Do tego służy pętla for i to ona jest tematem następnej strony.