Guide de l'instruction switch en C : Un guide pour les débutants

Salut à toi, futurs programmeurs ! Aujourd'hui, nous allons plonger dans l'une des structures de contrôle les plus utiles en programmation C : l'instruction switch. Ne t'inquiète pas si c'est nouveau pour toi ; je vais te guider pas à pas, comme j'ai fait pour des centaines d'étudiants au fil des ans. Alors, prends une tasse de ta boisson favorite et partons ensemble dans cette aventure de programmation !

Qu'est-ce qu'une instruction switch-case ?

Imaginons que tu es dans un glacier et que tu dois choisir un parfum. Tu as vanille, chocolat, fraise et menthe. Chaque choix mène à une différentes boules dans ton cornet. C'est exactement comme fonctionne l'instruction switch en programmation !

Une instruction switch est une instruction de flux de contrôle qui permet d'exécuter différents blocs de code en fonction de la valeur d'une variable ou d'une expression. C'est comme une version plus élégante et efficace de multiples instructions if-else.

Syntaxe de l'instruction switch-case

Jetons un coup d'œil à la structure de base d'une instruction switch :

switch (expression) {
case constant1:
// code à exécuter si l'expression est égale à constant1
break;
case constant2:
// code à exécuter si l'expression est égale à constant2
break;
...
default:
// code à exécuter si l'expression ne correspond à aucune constante
}

Ne t'inquiète pas si cela semble un peu intimidant au début. Nous allons le décomposer morceau par morceau.

Composants Clés :

1. switch : Ce mot-clé initialise l'instruction switch.
2. expression : C'est la valeur qui est évaluée.
3. case : Chaque cas représente une valeur possible de l'expression.
4. break : Ce mot-clé termine chaque bloc de cas.
5. default : C'est un bloc optionnel qui s'exécute si aucun cas ne correspond.

Fonctionnement de l'instruction switch-case

Maintenant, voyons comment cela fonctionne en pratique. Imaginons que nous créons un programme simple qui donne un message en fonction de la note d'un étudiant :

#include <stdio.h>

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

switch(grade) {
case 'A':
printf("Excellent !");
break;
case 'B':
printf("Bien joué !");
break;
case 'C':
printf("Bon travail !");
break;
case 'D':
printf("Tu as passé.");
break;
case 'F':
printf("Plus de chance la prochaine fois.");
break;
default:
printf("Note invalide");
}

return 0;
}

Dans cet exemple :

1. Nous avons une variable grade définie à 'B'.
2. L'instruction switch évalue grade.
3. Il vérifie chaque cas jusqu'à ce qu'il trouve une correspondance ('B' dans ce cas).
4. Lorsqu'il trouve une correspondance, il exécute le code dans ce cas ("Bien joué !").
5. L'instruction break quitte alors le bloc switch.

Si grade ne correspondait à aucun cas, le bloc default serait exécuté.

Diagramme de flux de l'instruction switch-case

Pour visualiser comment fonctionne une instruction switch, regardons un diagramme de flux :

+-------------+
|   Début     |
+-------------+
|
v
+-------------------+
| Évaluer l'expression|
+-------------------+
|
v
+----------------------+
| Comparer avec cas 1  |
+----------------------+
|
v
+-------------+
|    Correspond ?   |
+-------------+
Oui |     | Non
|     |
v     v
+-----------------+    +----------------------+
| Exécuter cas 1  |    | Comparer avec cas 2  |
+-----------------+    +----------------------+
|                     |
v                     v
+-----------+         +-------------+
|   Break   |         |    Correspond ?   |
+-----------+         +-------------+
|               Oui |     | Non
|                   |     |
|                   v     v
|         +-----------------+    +------------+
|         | Exécuter cas 2  |    |   ...      |
|         +-----------------+    +------------+
|                   |
|                   v
|            +-----------+
|            |   Break   |
|            +-----------+
|                   |
v                   v
+-----------+        +-----------+
|    Fin    | <------|   Default   |
+-----------+        +-----------+

Ce diagramme de flux montre comment l'instruction switch évalue chaque cas et exécute le bloc de code correspondant.

Règles pour utiliser l'instruction switch-case

Pour utiliser les instructions switch efficacement, garde ces règles à l'esprit :

Règle	Description
Type d'expression	L'expression switch doit être d'un type entier (int, char, etc.) ou d'un type énuméré.
Constantes des cas	Les étiquettes de cas doivent être des constantes ou des valeurs littérales, pas des variables.
Cas uniques	Chaque valeur de cas doit être unique dans une instruction switch.
Instruction break	Utilise break pour quitter le bloc switch après l'exécution d'un cas.
Cas default	Le cas default est optionnel et peut apparaître n'importe où dans le bloc switch.

Plus d'exemples d'instructions switch-case

Jetons un coup d'œil à quelques autres exemples pour solidifier notre compréhension.

Exemple 1 : Jours de la semaine

#include <stdio.h>

int main() {
int day = 4;

switch(day) {
case 1:
printf("Lundi");
break;
case 2:
printf("Mardi");
break;
case 3:
printf("Mercredi");
break;
case 4:
printf("Jeudi");
break;
case 5:
printf("Vendredi");
break;
case 6:
printf("Samedi");
break;
case 7:
printf("Dimanche");
break;
default:
printf("Numéro de jour invalide");
}

return 0;
}

Ce programme affichera "Jeudi" car day est défini à 4.

Exemple 2 : Calculatrice

#include <stdio.h>

int main() {
char operator;
double n1, n2;

printf("Entrez un opérateur (+, -, *, /) : ");
scanf("%c", &operator);
printf("Entrez deux opérandes : ");
scanf("%lf %lf", &n1, &n2);

switch(operator)
{
case '+':
printf("%.1lf + %.1lf = %.1lf", n1, n2, n1+n2);
break;
case '-':
printf("%.1lf - %.1lf = %.1lf", n1, n2, n1-n2);
break;
case '*':
printf("%.1lf * %.1lf = %.1lf", n1, n2, n1*n2);
break;
case '/':
printf("%.1lf / %.1lf = %.1lf", n1, n2, n1/n2);
break;
default:
printf("Erreur ! Opérateur incorrect");
}

return 0;
}

Ce programme crée une simple calculatrice utilisant une instruction switch.

Instructions switch en combinant plusieurs cas

Parfois, vous pourriez vouloir que plusieurs cas exécutent le même code. Vous pouvez faire cela en listant les cas ensemble :

#include <stdio.h>

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

switch(grade) {
case 'A':
case 'B':
case 'C':
printf("Tu as passé !");
break;
case 'D':
case 'F':
printf("Tu dois t'améliorer.");
break;
default:
printf("Note invalide");
}

return 0;
}

Dans cet exemple, les grades A, B et C entraînent tous "Tu as passé !", tandis que D et F entraînent "Tu dois t'améliorer."

Et voilà ! Tu viens d'apprendre l'instruction switch en C. Souviens-toi, la pratique rend parfait. Essaie d'écrire tes propres instructions switch et expérimente avec différents scénarios. Avant de te rendre compte, tu seras un expert en switch !

Bonne programmation, et puisses tes switches toujours trouver leur bon cas !

Credits: Image by storyset