switch…cas en C (instruction Switch en C) avec exemples
Benjamin marcheur
⚡ Résumé intelligent
L'instruction switch en C compare une expression à plusieurs étiquettes de cas et exécute le bloc correspondant, offrant une alternative plus propre aux longues chaînes if-else lorsqu'un programme doit choisir parmi de nombreuses valeurs entières ou de caractères fixes.
Qu’est-ce que l’instruction Switch en C ?
L'instruction switch en C teste la valeur d'une variable et la compare à plusieurs cas. Une fois le cas correspondant trouvé, le bloc d'instructions associé est exécuté.
Chaque cas dans un bloc d'un commutateur a un nom/numéro différent qui est appelé identifiant. La valeur fournie par l'utilisateur est comparée à tous les cas à l'intérieur du bloc de commutation jusqu'à ce que la correspondance soit trouvée.
Si une correspondance de casse n'est PAS trouvée, alors l'instruction par défaut est exécutée et le contrôle sort du bloc switch.
Syntaxe de changement de cas
Une syntaxe générale de la façon dont switch-case est implémenté dans un programme « C » est la suivante :
switch( expression ) { case value-1: Block-1; Break; case value-2: Block-2; Break; case value-n: Block-n; Break; default: Block-1; Break; } Statement-x;
- L'expression peut être une expression entière ou une expression de caractères.
- Value-1, 2, n sont des étiquettes de cas qui sont utilisées pour identifier chaque cas individuellement. N'oubliez pas que les étiquettes de cas ne doivent pas être identiques car cela pourrait créer un problème lors de l'exécution d'un programme. Supposons que nous ayons deux cas avec la même étiquette que « 1 ». Ensuite, lors de l'exécution du programme, le cas qui apparaît en premier sera exécuté même si vous souhaitez que le programme exécute un deuxième cas. Cela crée des problèmes dans le programme et ne fournit pas le résultat souhaité.
- Les étiquettes de cas se terminent toujours par deux points ( : ). Chacun de ces cas est associé à un bloc.
- Un bloc n’est rien d’autre que plusieurs instructions regroupées pour un cas particulier.
- Chaque fois que le commutateur est exécuté, la valeur de test-expression est comparée à tous les cas que nous avons définis à l'intérieur du commutateur. Supposons que l'expression de test contienne la valeur 4. Cette valeur est comparée à tous les cas jusqu'au cas dont l'étiquette quatre est trouvée dans le programme. Dès qu'un cas est trouvé, le bloc d'instructions associé à ce cas particulier est exécuté et le contrôle quitte le commutateur.
- Le mot-clé break indique dans chaque cas la fin d'un cas particulier. Si nous ne mettons pas le break dans chaque cas, même si le cas spécifique est exécuté, le commutateur en C continuera à exécuter tous les cas jusqu'à ce que la fin soit atteinte. Cela ne devrait pas arriver ; nous devons donc toujours mettre le mot-clé break dans chaque cas. Break mettra fin au cas une fois exécuté et le contrôle tombera du commutateur.
- Le cas par défaut est facultatif. Chaque fois que la valeur de test-expression ne correspond à aucun des cas à l’intérieur du commutateur, la valeur par défaut sera exécutée. Sinon, il n’est pas nécessaire d’écrire default dans le commutateur.
- Une fois le commutateur exécuté, le contrôle ira à l'instruction-x et l'exécution d'un programme continuera.
Organigramme de l'instruction Switch
Le diagramme suivant illustre comment un cas est sélectionné dans le cas de commutation :
Comment fonctionne le commutateur
Exemple de cas de commutation en C
Le programme suivant illustre l'utilisation de switch :
#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
- Dans le programme donné, nous avons initialisé un variable num avec la valeur 8.
- Une construction switch est utilisée pour comparer la valeur stockée dans la variable num et exécuter le bloc d'instructions associé au cas correspondant.
- Dans ce programme, puisque la valeur stockée dans la variable num est huit, un commutateur exécutera le cas dont l'étiquette de cas est 8. Après l'exécution du cas, la commande tombera du commutateur et le programme se terminera avec le résultat réussi par imprimer la valeur sur l'écran de sortie.
Essayez de changer la valeur de la variable num et notez le changement dans la sortie.
Par exemple, nous considérons le programme suivant qui utilise par défaut :
#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");}}
Sortie :
Other programming language
Lorsque vous travaillez avec un cas de commutation en C, vous regroupez plusieurs cas avec des étiquettes uniques. Vous devez introduire une instruction break dans chaque cas pour effectuer une branche à la fin d'une instruction switch.
Le cas facultatif par défaut s’exécute lorsqu’aucune autre correspondance n’est effectuée.
Nous considérons l’instruction switch suivante :
#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");}}
Sortie :
Four, Five, or Six.
Commutateur imbriqué en C
In C, nous pouvons avoir un commutateur interne intégré dans un commutateur externe. De plus, les constantes de cas des commutateurs interne et externe peuvent avoir des valeurs communes et sans aucun conflit.
Nous considérons le programme suivant, qui demande à l'utilisateur de saisir son identifiant. Si l'identifiant est valide, il lui demandera son mot de passe ; si le mot de passe est correct, le programme affichera le nom de l'utilisateur, sinon il affichera « Mot de passe incorrect » ; et si l'identifiant n'existe pas, le programme affichera « Identifiant incorrect ».
#include <stdio.h> int main() { int ID = 500; int password = 000; printf("Plese Enter Your ID:\n "); scanf("%d", & ID); switch (ID) { case 500: printf("Enter your password:\n "); scanf("%d", & password); switch (password) { case 000: printf("Welcome Dear Programmer\n"); break; default: printf("incorrect password"); break; } break; default: printf("incorrect ID"); break; } }
Sortie :
Plese Enter Your ID: 500 Enter your password: 000 Welcome Dear Programmer
- Dans le programme donné, nous avons initialisé deux variables : ID et mot de passe.
- Une instruction switch externe est utilisée pour comparer la valeur saisie dans la variable ID. Elle exécute le bloc d'instructions associé au cas correspondant (lorsque ID == 500).
- Si l'instruction de bloc est exécutée avec la casse correspondante, une instruction switch interne est utilisée pour comparer les valeurs saisies dans la variable password et exécuter les instructions liées à la casse correspondante (lorsque password==000).
- Sinon, le cas de commutation déclenchera le cas par défaut et imprimera le texte approprié concernant le plan du programme.
Pourquoi avons-nous besoin d’un boîtier Switch ?
Il existe un problème potentiel avec le instruction if-else c'est-à-dire que la complexité du programme augmente à mesure que le nombre de chemins alternatifs augmente. Si vous utilisez plusieurs constructions if-else dans le programme, celui-ci peut devenir difficile à lire et à comprendre. Parfois, cela peut même dérouter le développeur qui a lui-même écrit le programme.
La solution à ce problème est l’instruction switch.
Règles pour l'instruction switch
Suivez ces règles lors de l'écriture d'une instruction switch en C :
- Une expression doit toujours s'exécuter sur un résultat.
- Les étiquettes de cas doivent être constantes et uniques.
- Les étiquettes de cas doivent se terminer par deux points ( : ).
- Un mot-clé break doit être présent dans chaque cas.
- Il ne peut y avoir qu'une seule étiquette par défaut.
- Nous pouvons imbriquer plusieurs instructions switch.
