L'utilisation d'une instruction switch vous permet de tester plusieurs conditions et d'exécuter un bloc spécifique uniquement si la condition est vraie. Bien que cela fonctionne de manière similaire à une instruction if…else if….else, la syntaxe est plus simple et plus facile à lire et à gérer.
Ce didacticiel vise à vous montrer comment créer et utiliser des instructions switch en programmation C.
Utilisation de base
L'instruction switch est facile à implémenter. La syntaxe générale est la suivante :
changer (expr) {
casevar1:
// code
Pause;
casevar2:
//code
Pause;
casevar3:
// code
Pause;
casevarN:
// code
Pause;
...
….
….
défaut:
//code
}
Comment ça fonctionne
L'instruction switch implémente une logique simple pour évaluer chacun des blocs de cas.
Il commence par évaluer l'expression à l'intérieur du bloc switch. Ensuite, il compare la valeur du bloc de commutation à chaque bloc de cas.
Une fois qu'il a localisé une correspondance dans l'un des blocs de cas définis, il exécute le code à l'intérieur de ce bloc jusqu'à ce qu'il rencontre le mot-clé break.
S'il ne rencontre aucune correspondance dans l'un des blocs de cas définis, il passe à l'instruction par défaut et exécute le code qu'il contient. Le bloc par défaut est facultatif et peut être omis s'il n'y a pas d'action requise pour un scénario qui ne correspond pas
REMARQUE: Il est bon de s'assurer que chaque instruction case se termine par une instruction break pour empêcher l'exécution de toutes les instructions après le bloc correspondant.
Exemple de déclaration de cas de commutation C
Illustrons l'instruction switch avec un exemple très simple :
#comprendreint main() {
entieroù= 5;
changer (où) {
cas3:
imprimer ('La valeur est 3');
Pause;
cas4:
imprimer ('La valeur est 4');
Pause;
cas5:
imprimer ('La valeur est 5');
Pause;
défaut:
imprimer ('La valeur n'est ni 3, 4 ni 5');
}
retour0;
}
Si nous exécutons l'exemple ci-dessus, nous devrions obtenir une sortie similaire à celle ci-dessous :
La valeur est5L'organigramme suivant illustre la logique du programme ci-dessus :
Une déclaration de commutateur imbriqué
C vous permet d'avoir des instructions switch imbriquées dans une instruction switch. L'instruction switch imbriquée est liée à la valeur du commutateur externe.
Considérez l'exemple suivant :
#comprendreint main() {
entierdépartement= 5;
intaccess_code= 2028;
changer (département) {
cas 1:
changer (code d'accès) {
cas2021:
imprimer ('[+] Code d'accès valide !');
Pause;
défaut:
imprimer ('[-] Code d'accès invalide!');
}
Pause;
défaut:
imprimer ('[-] Seul le département 1 est autorisé !');
}
retour0;
}
Dans l'exemple ci-dessus, nous implémentons deux instructions switch. Le premier vérifie si le département fourni est 1. Si vrai, il passe au bloc de commutation suivant et vérifie le code d'accès valide.
Si la valeur de dept n'est pas un, l'exécution passe au bloc par défaut.
Ce qui suit est l'exécution du code ci-dessus avec un département et un code d'accès corrects et incorrects.
Dans le premier exemple, le département et le code d'accès sont corrects ; ainsi, l'exécution n'atteint jamais les blocs par défaut.
Dans le deuxième exemple, le département et le code d'accès sont incorrects ; par conséquent, l'exécution saute immédiatement au premier bloc par défaut.
Directives pour les instructions Switch
Voici des instructions rapides à noter lors de la création d'instructions switch en C.
- Vous devez transmettre une expression au mot clé switch.
- Les instructions Case doivent vérifier les valeurs uniques
- Terminez chaque bloc case à l'aide du mot-clé break.
- Vous pouvez imbriquer plusieurs instructions switch.
- Vous pouvez inclure une instruction par défaut lorsqu'une action est nécessaire pour les cas non correspondants.
Conclusion
Ce guide vous a expliqué les bases de la création et de l'utilisation d'instructions de commutateur C. Les instructions Switch sont utiles lorsque vous avez des cas de décision complexes qui peuvent être difficiles à implémenter avec l'instruction and if else.