Communiquez les cas en C
Il y a quelques restrictions sur l'utilisation de ces cas de commutateur. Tout d'abord, l'expression de Switch est nécessaire pour avoir le type de données char ou entier. La valeur de chaque cas doit être utilisée à l'intérieur de l'instruction de cas de commutateur et son type de données doit être un entier ou un const char (caractère constant).
Procédure
La procédure de cet article explique le concept du cas de commutateur dans la langue C. Nous suivons la procédure séquentielle où nous apprenons d'abord la syntaxe du cas de commutateur. Ensuite, nous essayons de résoudre pratiquement quelques exemples pour les différents problèmes des cas de commutation.
Syntaxe
Switch (Expression)
Case Value_1:
// instruction à exécuter dans l'affaire_1
Casser; // pour sortir de la déclaration
Case Value_2:
// instruction à exécuter dans l'affaire_2
Casser; // pour sortir de la déclaration
.
.
.
Défaut:
// Déclaration en cas de correspondance avec les cas
Exemple 1:
Nous essaierons de résoudre l'exemple le plus simple où nous apprenons à implémenter pratiquement les cas de commutateur. Supposons que nous avons un exemple où nous voulons d'abord lire l'entrée de l'utilisateur. Et que l'utilisateur donne l'entrée, nous essayons de le faire correspondre avec les valeurs de l'instruction Switch. Si nous trouvons la correspondance avec l'une des instructions de commutation ou une valeur de cas de commutateur, nous exécutons l'instruction dans ce cas.
Pour l'implémentation, nous créons un projet dans le compilateur Visual Studio C en sélectionnant le nouveau projet dans l'option «Fichiers» dans la barre d'outils. Cela nous conduit au projet nouvellement créé. Ensuite, nous ajoutons ce projet au chemin des référentiels C à l'aide du fichier source en enregistrant le nom du projet avec l'extension «C». Une fois le projet créé, nous importons le «STdio. H ”Fichier d'en-tête comme« # include ». Ceci est fait pour s'assurer que le programme peut utiliser les fonctions intégrées de «STdio» telles que printf () et scanf (). Maintenant, nous déclarons la fonction principale avec un entier de type retour. Dans le corps de cette fonction principale, nous initialisons une variable «num» ayant le type de données «int» et la valeur «0» qui lui est attribuée. Nous prenons la valeur de cette variable Num de l'utilisateur et de cet objectif. Nous appelons la méthode scanf () et passons l'adresse du num comme «& num» et le spécificateur de format comme «% d». Cela permet au nombre de prendre sa valeur de l'entrée utilisateur.
Pour imposer les conditions à la valeur de ce NUM, nous utilisons les instructions de cas de commutateur et nous passons le nombre à l'expression du commutateur et définissons un premier cas de commutateur avec la valeur 20 dans son instruction. Nous imprimons l'expression «num est 20», puis cassons l'instruction. Nous définissons trois à quatre cas de commutation de ce type. Enfin, nous définissons l'instruction par défaut qui imprime l'expression «num n'est pas une correspondance avec un cas de commutateur» si nous n'avons trouvé la correspondance de l'entrée de l'utilisateur Num avec l'une des valeurs de cas de commutateur. Cet exemple est mis en œuvre sous la forme d'un programme en C comme:
#inclure
int main()
int num = 0;
printf ("Entrez un nombre:");
scanf ("% d", & num);
commutateur (num)
Cas 20:
printf ("num est 20");
casser;
Cas 30:
printf ("num est 30");
casser;
Cas 50:
printf ("num est 50");
casser;
défaut:
printf ("num n'est pas égal à 20, 20 ou 50");
retour 0;
Nous prenons l'entrée de l'utilisateur pour NUM en tant que «5». Cette valeur ne correspond à aucune valeur dans le cas du commutateur. Par conséquent, l'instruction par défaut s'affiche dans la sortie. Si nous donnons à l'entrée de l'utilisateur un nombre comme «20», cette valeur correspond au premier cas de commutateur et l'instruction du premier cas de commutateur est exécutée et affichée dans la sortie.
Exemple 2:
Le deuxième exemple de ce guide essaiera d'implémenter un autre exemple en utilisant le cas de commutateur dans la langue C. Nous commençons par créer d'abord le projet dans le code Visual Studio, puis en importation de la bibliothèque «# include» pour les fonctions d'impression et de numérisation. Après cette étape, nous créons une fonction principale avec le type de retour «int». Nous initialisons les deux variables «A» et «B» avec les valeurs «20» et «10» respectivement. Dans l'expression du commutateur, nous passons la condition si «A» est supérieur à «B». Si la somme de ces deux variables «A» et «B» est également supérieure à «0», nous aurons le premier cas de commutateur avec la valeur booléenne «1» comme «vrai». Si l'expression du commutateur est vraie, elle imprime l'expression comme vraie et que le deuxième cas de commutateur aura une valeur «0». Si l'expression du commutateur est erronée, l'instruction par défaut est exécutée. Si l'expression n'est pas vraie ou fausse, l'instruction par défaut imprime l'expression «rien».
#inclure
int main ()
int a = 20, b = 10;
commutateur (a> b && a + b> 0)
cas 1:
printf ("true");
casser;
Cas 0:
printf ("false");
casser;
défaut:
printf ("rien");
Nous avons exécuté l'exemple précédemment expliqué sous la forme du programme. La sortie du programme est devenue vraie car l'expression du commutateur correspondait au premier cas de commutateur. Ainsi, la sortie affiche «vrai» comme sa déclaration.
Conclusion
Le cas de commutateur dans le langage C est utilisé lorsque nous avons plus d'une option pour la variable unique que nous devons exécuter. Le commutateur trouve la meilleure correspondance pour l'expression du commutateur et exécute l'instruction en conséquence. Si nous ne trouvons aucune correspondance pour l'expression de Switch, l'instruction par défaut est exécutée. Nous avons implémenté les deux exemples de ces tels.