L'instruction switch en C
switch est une structure de contrôle multidirectionnelle qui évalue une expression entière et redirige l'exécution vers le case dont la valeur correspond. Elle offre une alternative plus lisible et souvent plus rapide à une chaîne de if-else if quand on compare une même variable à plusieurs valeurs constantes.| Critère | if-else if | switch |
|---|---|---|
| Types testables | Tout type (entier, réel, chaîne…) | Entier ou char uniquement |
| Conditions | Expressions booléennes quelconques | Valeurs constantes entières uniquement |
| Lisibilité | Moins lisible pour nombreuses branches | Plus lisible pour nombreuses valeurs |
| Performance | Évaluation séquentielle | Saut direct (table de branchement) |
| Fall-through | Non applicable | Oui (sans break) |
1. Syntaxe
switch (expression) {
case valeur1:
instructions;
break; /* sortie du switch */
case valeur2:
instructions;
break;
case valeur3:
case valeur4: /* regroupement de cas */
instructions;
break;
default: /* optionnel — exécuté si aucun cas ne correspond */
instructions;
}Déroulement d'un switch :
- Évaluation de l'expression → valeur entière
- Comparaison avec chaque
case, dans l'ordre - Saut vers le
casecorrespondant (oudefault) - Exécution jusqu'au prochain
breakou accolade fermante
Expressions et valeurs de case valides
| Expression switch | Valide ? | Raison |
|---|---|---|
switch(a) (int) | Valide | Entier |
switch(c) (char) | Valide | Char converti en entier |
switch(a + 4) | Valide | Expression entière |
switch(f(a, 2)) | Valide | Retour entier d'une fonction |
switch(b) (float) | Invalide | Virgule flottante interdite |
switch("nom") | Invalide | Chaîne de caractères interdite |
| Valeur de case | Valide ? | Raison |
|---|---|---|
case 2: | Valide | Constante entière |
case 2+3: | Valide | Expression constante entière |
case 'a': | Valide | Caractère (= entier ASCII) |
case 1, 2, 3: | Invalide | Valeurs multiples interdites |
case 3.5: | Invalide | Valeur réelle interdite |
case a: (variable) | Invalide | Doit être une constante de compilation |
2. L'instruction break et le fall-through
break Sans break, l'exécution ne s'arrête pas au case correspondant : elle continue dans les cases suivants (fall-through) jusqu'au prochain break ou à la fin du switch. C'est la cause la plus fréquente de bugs dans les switch:/* Sans break — saisie : 3 */
switch (3) {
case 1: printf("un\n");
case 2: printf("deux\n");
case 3: printf("trois\n"); /* ← exécution commence ici */
case 4: printf("quatre\n"); /* ← continue ici (fall-through) */
default: printf("autre\n"); /* ← et ici */
}
/* Sortie : trois quatre autre */
/* Avec break — comportement attendu */
switch (3) {
case 1: printf("un\n"); break;
case 2: printf("deux\n"); break;
case 3: printf("trois\n"); break; /* ← s'arrête ici */
case 4: printf("quatre\n"); break;
default: printf("autre\n");
}
/* Sortie : trois */Exemple n°1 — Afficher le jour de la semaine (avec break)
#include <stdio.h>
int main(void)
{
int jour;
printf("Saisir le numéro du jour (1-7) : ");
scanf("%d", &jour);
switch (jour) {
case 1: printf("Lundi\n"); break;
case 2: printf("Mardi\n"); break;
case 3: printf("Mercredi\n"); break;
case 4: printf("Jeudi\n"); break;
case 5: printf("Vendredi\n"); break;
case 6: printf("Samedi\n"); break;
case 7: printf("Dimanche\n"); break;
default: printf("Numéro invalide (attendu : 1 à 7)\n");
}
return 0;
}Saisir le numéro du jour (1-7) : 3 Mercredi
Saisir le numéro du jour (1-7) : 9 Numéro invalide (attendu : 1 à 7)
3. Regroupement de cases
Plusieurs case peuvent partager le même bloc d'instructions en les plaçant à la suite sans break entre eux — c'est le seul usage intentionnel du fall-through.
Exemple n°2 — Classer un jour en semaine / week-end
#include <stdio.h>
int main(void)
{
int jour;
printf("Saisir le numéro du jour (1-7) : ");
scanf("%d", &jour);
switch (jour) {
case 1:
case 2:
case 3:
case 4:
case 5:
printf("Jour de semaine\n");
break;
case 6:
case 7:
printf("Week-end\n");
break;
default:
printf("Numéro invalide\n");
}
return 0;
}Saisir le numéro du jour (1-7) : 6 Week-end
4. switch sur un caractère
Exemple n°3 — Calculatrice simple avec switch sur char
#include <stdio.h>
int main(void)
{
int a, b;
char op;
printf("Saisir a : ");
scanf("%d", &a);
printf("Saisir b : ");
scanf("%d", &b);
printf("Opérateur (+, -, *, /) : ");
scanf(" %c", &op); /* espace avant %c pour ignorer le \n résiduel */
switch (op) {
case '+':
printf("%d + %d = %d\n", a, b, a + b);
break;
case '-':
printf("%d - %d = %d\n", a, b, a - b);
break;
case '*':
printf("%d * %d = %d\n", a, b, a * b);
break;
case '/':
if (b == 0)
printf("Erreur : division par zéro\n");
else
printf("%d / %d = %d\n", a, b, a / b);
break;
default:
printf("Opérateur invalide : '%c'\n", op);
}
return 0;
}Saisir a : 10 Saisir b : 4 Opérateur (+, -, *, /) : * 10 * 4 = 40
Saisir a : 10 Saisir b : 0 Opérateur (+, -, *, /) : / Erreur : division par zéro
scanf(" %c") pour les caractères Après un scanf("%d"), un '\n' résiduel reste dans le tampon. Ajouter un espace avant %cle consomme automatiquement :scanf("%d", &b);
scanf("%c", &op); /* lirait le '\n' résiduel */
scanf(" %c", &op); /* espace — consomme les espaces blancs avant */5. Application — Menu interactif
Exemple n°4 — Menu de gestion d'étudiants
#include <stdio.h>
int main(void)
{
int choix;
do {
printf("\n========= Menu =========\n");
printf("1. Ajouter un étudiant\n");
printf("2. Afficher la liste\n");
printf("3. Rechercher un étudiant\n");
printf("4. Supprimer un étudiant\n");
printf("0. Quitter\n");
printf("Votre choix : ");
scanf("%d", &choix);
switch (choix) {
case 1:
printf("→ Ajout d'un étudiant\n");
break;
case 2:
printf("→ Affichage de la liste\n");
break;
case 3:
printf("→ Recherche d'un étudiant\n");
break;
case 4:
printf("→ Suppression d'un étudiant\n");
break;
case 0:
printf("Au revoir !\n");
break;
default:
printf("Choix invalide — entrer un nombre entre 0 et 4\n");
}
} while (choix != 0);
return 0;
}========= Menu ========= 1. Ajouter un étudiant 2. Afficher la liste 3. Rechercher un étudiant 4. Supprimer un étudiant 0. Quitter Votre choix : 2 → Affichage de la liste ... Votre choix : 0 Au revoir !
Récapitulatif
| Élément | Rôle | Obligatoire ? | Point clé |
|---|---|---|---|
switch(expr) | Évalue l'expression | Oui | Entier ou char uniquement |
case val: | Branche pour la valeur | Au moins 1 | Constante entière uniquement, valeurs uniques |
break; | Sort du switch | Non (mais recommandé) | Sans break → fall-through vers le case suivant |
default: | Cas par défaut | Non | Exécuté si aucun case ne correspond |
| Regroupement | Plusieurs cases → même bloc | — | Cases consécutifs sans break entre eux |
Discussion (0)
Soyez le premier à laisser un commentaire !
Laisser un commentaire
Votre commentaire sera visible après modération.