Comprendre Switch-Case en C : Syntaxe, exemples et bonnes pratiques

Qu'est-ce que l'instruction switch en C ?

La construction switch évalue une seule expression et dirige le flux du programme vers l'étiquette case correspondante. Si aucune correspondance n'est trouvée, le bloc default optionnel s'exécute. Cet outil de prise de décision est particulièrement utile pour gérer des valeurs discrètes et constantes telles que les options de menu, codes d'erreur ou sélections utilisateur.

Chaque case est identifié de manière unique par une expression constante. Lorsque la valeur de l'expression correspond à une étiquette case, le bloc d'instructions correspondant s'exécute, et l'exécution sort du switch (sauf si un break est omis, ce qui cause une « fall-through » ou passage à travers).

Syntaxe Switch-Case

switch (expression) {
    case constante1:
        // instructions
        break;
    case constante2:
        // instructions
        break;
    // …
    default:
        // instructions
        break;
}
// instructions suivant le switch

• L'expression doit évaluer à un type intégral ou enum.
• Les étiquettes case sont des valeurs constantes ; les doublons créent une ambiguïté et doivent être évités.
• Chaque case se termine par deux-points et est suivi d'un bloc de code.
• Utilisez break pour terminer un case ; sans lui, l'exécution continue dans les cases suivantes (fall-through).
• Le bloc default est optionnel et ne s'exécute que lorsqu'aucun case ne correspond.

Comment fonctionne l'instruction switch

Le diagramme de flux suivant illustre le processus de décision pour une instruction switch :

Exemple 1 : Switch basique

#include <stdio.h>
int main() {
    int num = 8;
    switch (num) {
        case 7:
            printf("Value is 7");
            break;
        case 8:
            printf("Value is 8");
            break;
        case 9:
            printf("Value is 9");
            break;
        default:
            printf("Out of range");
            break;
    }
    return 0;
}

Sortie :

Value is 8

Exemple 2 : Utilisation de default

#include <stdio.h>
int main() {
    int language = 10;
    switch (language) {
        case 1:
            printf("C#\n");
            break;
        case 2:
            printf("C\n");
            break;
        case 3:
            printf("C++\n");
            break;
        default:
            printf("Other programming language\n");
    }
    return 0;
}

Sortie :

Other programming language

Exemple 3 : Cases combinées

#include <stdio.h>
int main() {
    int number = 5;
    switch (number) {
        case 1:
        case 2:
        case 3:
            printf("One, Two, or Three.\n");
            break;
        case 4:
        case 5:
        case 6:
            printf("Four, Five, or Six.\n");
            break;
        default:
            printf("Greater than Six.\n");
    }
    return 0;
}

Sortie :

Four, Five, or Six.

Switch imbriqués

Les switch peuvent être imbriqués, permettant une prise de décision hiérarchique. L'exemple suivant démontre un flux d'authentification simple :

#include <stdio.h>
int main() {
    int ID, password;
    printf("Please Enter Your ID:\n");
    scanf("%d", &ID);
    switch (ID) {
        case 500:
            printf("Enter your password:\n");
            scanf("%d", &password);
            switch (password) {
                case 0:
                    printf("Welcome Dear Programmer\n");
                    break;
                default:
                    printf("Incorrect password\n");
            }
            break;
        default:
            printf("Incorrect ID\n");
    }
    return 0;
}

SORTIE :

 Please Enter Your ID: 500
Enter your password: 000
Welcome Dear Programmer

Pourquoi switch est préférable aux if-else extensifs

Bien que les chaînes if-else puissent atteindre la même logique, elles deviennent ingérables à mesure que le nombre d'options augmente. Les instructions switch offrent une syntaxe plus claire, une meilleure lisibilité et peuvent être optimisées par le compilateur en tables de saut pour les expressions constantes.

Règles pour utiliser switch

• L'expression de contrôle doit être un type intégral ou enum.
• Les étiquettes case doivent être des valeurs constantes et uniques.
• Chaque étiquette case se termine par deux-points.
• Utilisez break pour éviter les fall-through non intentionnels.
• Une seule étiquette default est autorisée.
• Les switch imbriqués sont autorisés et souvent utiles.

Points clés à retenir

• Switch est un outil robuste de prise de décision pour les valeurs discrètes.
• Incluez toujours un break (sauf fall-through intentionnel).
• Gardez les étiquettes case uniques et constantes.
• Le bloc default est optionnel mais recommandé pour la gestion d'erreurs.
• Les switch imbriqués fournissent une logique de décision en couches.