Instruction switch en C++ : cas, fall-through et break

À quoi sert switch

Un switch compare une valeur à une liste d'options fixes et exécute la branche qui correspond. Quand vous vous surprenez à écrire une longue chaîne de if/else if qui teste sans cesse la même variable contre différentes constantes, un switch exprime cette intention plus clairement, et compile souvent vers une table de sauts plus rapide.

Il ne fait que des tests d'égalité contre des constantes connues à la compilation sur une valeur de type entier. Il ne peut pas tester des plages, comparer des chaînes ni combiner des conditions. Pour l'un de ces cas, restez sur if/else.

Le switch de base

Vous donnez une valeur à switch, puis vous listez des étiquettes case pour les valeurs qui vous intéressent. Chaque branche se termine par 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;
}

La valeur 3 correspond à case 3:, donc "Wednesday" s'affiche et break saute hors du switch. La branche default est le cas attrape-tout : elle s'exécute quand aucun case ne correspond. Elle est facultative, mais incluez-la sauf si vous êtes certain que toutes les valeurs sont traitées.

Notez que les étiquettes case sont de simples constantes suivies de deux-points, pas des conditions. Vous écrivez case 3:, jamais case day == 3:.

break et fall-through

C'est le piège le plus important de switch en C++. Après qu'un case correspond, l'exécution ne s'arrête pas au case suivant : elle continue tout droit jusqu'à rencontrer un break ou l'accolade fermante. Regardez ce qui se passe quand les instructions break sont absentes :

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

Vous pourriez vous attendre à seulement "one". Au lieu de cela, les quatre lignes s'affichent : correspondre à case 1: fait entrer dans le switch à cet endroit, puis l'exécution tombe à travers toutes les étiquettes situées en dessous. Ajoutez un break; après chaque branche et vous obtenez l'unique ligne souhaitée. Oublier un break est la source classique des bugs du type « pourquoi mon switch exécute-t-il trop de code ? ».

Fall-through intentionnel pour regrouper des cas

Le fall-through n'est pas toujours une erreur : c'est la façon idiomatique de faire partager un même corps à plusieurs cas. Laissez les cas vides (aucune instruction, aucun break) et ils s'enchaînent tous vers le bloc suivant :

#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' et 'C' aboutissent tous à la même ligne "Pass" parce que les deux premiers cas sont vides et tombent à travers vers le troisième. C'est propre et voulu. Quand vous voulez vraiment tomber à travers après avoir exécuté du code, documentez-le avec un commentaire — ou, à partir de C++17, avec l'attribut [[fallthrough]];, qui dit au compilateur « oui, c'était voulu » et fait taire les avertissements de fall-through.

switch sur des enums

switch s'associe naturellement aux enums, puisqu'un enum est exactement « une valeur parmi un ensemble fixe ». Les compilateurs peuvent aussi vous avertir si vous oubliez de traiter l'un des énumérateurs :

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

Avec un enum class à portée, vous devez qualifier chaque étiquette (Direction::East). Comme chaque énumérateur est couvert, aucun default n'est nécessaire — et beaucoup de compilateurs vous avertiront si vous ajoutez plus tard une cinquième direction en oubliant d'ajouter son cas. Cette aide du compilateur est une grande raison de préférer switch aux chaînes de if/else pour les enums.

Un piège : les déclarations à l'intérieur d'un case

Vous ne pouvez pas déclarer une variable avec un initialiseur dans un case et la rendre visible dans les autres cas sans lui donner sa propre portée. C'est une erreur de compilation fréquente :

switch (x) {
    case 1:
        int n = 10;   // erreur : le saut vers case 2 contourne cette initialisation
        cout << n;
        break;
    case 2:
        cout << "two";
        break;
}

Le compilateur le rejette parce que tomber dans case 2: sauterait par-dessus l'initialisation de n alors que n est encore dans la portée. La solution est d'entourer le corps du case de ses propres accolades, donnant à la variable son propre bloc :

#include <iostream>
using namespace std;

int main() {
    int x = 1;

    switch (x) {
        case 1: {
            int n = 10;   // maintenant limité à ce bloc — parfait
            cout << n << endl;
            break;
        }
        case 2:
            cout << "two" << endl;
            break;
    }

    return 0;
}

Chaque fois qu'un case a besoin de sa propre variable locale, donnez-lui des accolades. Cela empêche aussi la variable de fuir vers les cas situés en dessous.

Suivant : la boucle for

switch et if permettent à votre programme de choisir quel code exécuter une seule fois. Mais beaucoup de travail consiste à faire la même chose de nombreuses fois : compter, parcourir une liste, répéter jusqu'à ce qu'une condition change. La boucle for est l'outil de prédilection pour cela, et c'est la page suivante.