logo

TechCodeview

Instruction de commutation C

L'instruction switch en C est une alternative à l'instruction à relais if-else-if qui nous permet d'exécuter plusieurs opérations pour les différentes valeurs possibles d'une seule variable appelée variable switch. Ici, nous pouvons définir diverses instructions dans les cas multiples pour les différentes valeurs d'une seule variable.

La syntaxe de l'instruction switch dans langue c est donné ci-dessous :

 switch(expression){ case value1: //code to be executed; break; //optional case value2: //code to be executed; break; //optional ...... default: code to be executed if all cases are not matched; }

Règles pour l'instruction switch en langage C

  1. Le changer d'expression doit être de type entier ou caractère.
  2. Le valeur du cas doit être un entier ou un caractère constant.
  3. Le valeur du cas ne peut être utilisé que dans l’instruction switch.
  4. Le instruction de pause dans le cas de l'interrupteur, ce n'est pas indispensable. C'est facultatif. Si aucune instruction break n'est trouvée dans le cas, tous les cas seront exécutés présents après le cas correspondant. Il est connu comme tomber dans l'état de l'instruction switch C.

Essayons de le comprendre par les exemples. Nous supposons qu'il existe les variables suivantes.

 int x,y,z; char a,b; float f;
Changement valideChangement invalideCas valideCas invalide
interrupteur(x)interrupteur(f)cas 3 ;cas 2.5 ;
commutateur (x> y)commutateur (x+2,5)cas « a » ;cas x ;
interrupteur (a+b-2)cas 1+2 ;cas x+2 ;
commutateur (fonction (x, y))cas 'x'>'y' ;cas 1,2,3 ;

Organigramme de l'instruction switch en C

flux de l'instruction switch en c

Fonctionnement de l'instruction switch case

Tout d’abord, l’expression entière spécifiée dans l’instruction switch est évaluée. Cette valeur est ensuite mise en correspondance une à une avec les valeurs constantes données dans les différents cas. Si une correspondance est trouvée, alors toutes les instructions spécifiées dans ce cas sont exécutées avec tous les cas présents après ce cas, y compris l'instruction par défaut. Deux cas ne peuvent pas avoir des valeurs similaires. Si le cas correspondant contient une instruction break, alors tous les cas présents après cela seront ignorés et le contrôle sortira du commutateur. Sinon, tous les cas suivant le cas correspondant seront exécutés.

Comment fonctionne l’instruction C switch ?

Passons en revue le processus étape par étape du fonctionnement de l'instruction switch en C :

Considérer ce qui suit instruction de commutation :

Programme C : 

 #include int main() { int num = 2; switch (num) { case 1: printf('Value is 1
'); break; case 2: printf('Value is 2
'); break; case 3: printf('Value is 3
'); break; default: printf('Value is not 1, 2, or 3
'); break; } return 0; }

Sortir 

 Value is 2

Processus étape par étape :

  1. Le numéro de variable de commutation est évalué. Dans ce cas, sur une est initialisé avec le valeur 2 .
  2. Le valeur numérique évaluée (2) est comparé aux constantes spécifiées dans chaque étiquette de cas à l'intérieur du bloc de commutation .
  3. Le instruction de commutation correspond à valeur évaluée (2) avec la constante spécifiée dans le deuxième cas (cas 2) . Puisqu'il y a une correspondance, le programme passe au bloc de code associé au cas correspondant (cas 2) .
  4. Le bloc de code associé à cas 2 est exécuté, ce qui imprime 'La valeur est 2' à la console.
  5. Le 'casser' le mot-clé est présent dans le bloc de code de cas 2 . En conséquence, le programme quitte l'instruction switch immédiatement après l'exécution du bloc de code.
  6. Le contrôle du programme continue après le instruction de commutation , et toute déclaration suivant le instruction de commutation sont exécutés. Dans ce cas, il n’y a aucune instruction après le changement, le programme se termine donc.
  7. Le instruction de commutation évalué la valeur du numéro de variable , a trouvé une correspondance avec le cas 2, a exécuté le bloc de code correspondant, puis a quitté le bloc de commutation en raison de la présence du déclaration « pause » .

Exemple d'une instruction switch en C

Voyons un exemple simple d'instruction de changement de langage C.

 #include int main(){ int number=0; printf('enter a number:'); scanf('%d',&number); switch(number){ case 10: printf('number is equals to 10'); break; case 50: printf('number is equal to 50'); break; case 100: printf('number is equal to 100'); break; default: printf('number is not equal to 10, 50 or 100'); } return 0; }

Sortir

remplacer une couleur dans Gimp 
 enter a number:4 number is not equal to 10, 50 or 100 enter a number:50 number is equal to 50

Exemple de cas de commutation 2

 #include int main() { int x = 10, y = 5; switch(x>y && x+y>0) { case 1: printf('hi'); break; case 0: printf('bye'); break; default: printf(' Hello bye '); } }

Sortir 

 hi

Mot-clé Break et Default dans l'instruction Switch

Expliquons et définissons le 'casser' et mots-clés « par défaut » dans le contexte de l'instruction switch, avec un exemple de code et de sortie.

1. Casser le mot-clé :

Le mot-clé « pause » est utilisé dans le bloc de code de chaque cas pour terminer prématurément l'instruction switch. Lorsque le programme rencontre un déclaration « pause » à l'intérieur d'un bloc de boîtier, il sort immédiatement du instruction de commutation , empêchant l'exécution des blocs de cas suivants. Le déclaration « pause » est crucial pour éviter les instructions switch' 'tomber dans' comportement.

Exemple:

Prenons un programme pour comprendre l'utilisation du casser le mot-clé en C.

 #include int main() { int num = 3; switch (num) { case 1: printf('Value is 1
'); break; // Exit the switch statement after executing this case block case 2: printf('Value is 2
'); break; // Exit the switch statement after executing this case block case 3: printf('Value is 3
'); break; // Exit the switch statement after executing this case block default: printf('Value is not 1, 2, or 3
'); break; // Exit the switch statement after executing the default case block } return 0; }

Sortir 

 Value is 3

Explication:

Dans cet exemple, le instruction de commutation évalue la valeur du numéro de variable (lequel est 3 ) et le fait correspondre avec cas 3 . Le bloc de code associé à cas 3 est exécuté, impression 'La valeur est 3' à la console. Le déclaration « pause » dans cas 3 garantit que le programme quitte l'instruction switch immédiatement après l'exécution de ce bloc de cas, empêchant l'exécution de tout autre cas.

2. Mot-clé par défaut :

Quand aucun des constantes de cas correspond à expression évaluée , il fonctionne comme un cas fourre-tout . S'il n'existe aucun cas correspondant et qu'un Le cas « par défaut » existe , le bloc de code associé au 'défaut' l'affaire est exécutée. Il est souvent utilisé pour gérer des circonstances dans lesquelles aucune des situations indiquées ne s'applique à l'entrée fournie.

Exemple:

Prenons un programme pour comprendre l'utilisation du mot-clé par défaut en C.

 #include int main() { int num = 5; switch (num) { case 1: printf('Value is 1
'); break; case 2: printf('Value is 2
'); break; case 3: printf('Value is 3
'); break; default: printf('Value is not 1, 2, or 3
'); break; // Exit the switch statement after executing the default case block } return 0; }

Sortir 

 Value is not 1, 2, or 3

Explication:

Dans cet exemple, le instruction de commutation examine la valeur du numéro de variable (lequel est 5 ). Comme aucun cas ne correspond au num, le programme exécute le bloc de code associé au cas 'par défaut' . Le déclaration « pause » à l'intérieur de cas 'par défaut' garantit que le programme quitte le instruction de commutation après avoir exécuté le 'défaut' bloc de cas.

Les deux 'casser' et mots-clés « par défaut » jouent un rôle essentiel dans le contrôle du flux d’exécution au sein d’une instruction switch. Le déclaration « pause » aide à prévenir le comportement de chute, tandis que le cas 'par défaut' fournit un moyen de gérer les cas sans précédent.

L'instruction C Switch est un échec

En langage C, l'instruction switch est interrompue ; cela signifie que si vous n'utilisez pas d'instruction break dans le cas switch, tous les cas après le cas correspondant seront exécutés.

Essayons de comprendre l'état de transition de l'instruction switch à l'aide de l'exemple donné ci-dessous.

 #include int main(){ int number=0; printf('enter a number:'); scanf('%d',&number); switch(number){ case 10: printf('number is equal to 10
'); case 50: printf('number is equal to 50
'); case 100: printf('number is equal to 100
'); default: printf('number is not equal to 10, 50 or 100'); } return 0; }

Sortir 

 enter a number:10 number is equal to 10 number is equal to 50 number is equal to 100 number is not equal to 10, 50 or 100

Sortir 

 enter a number:50 number is equal to 50 number is equal to 100 number is not equal to 10, 50 or 100

Instruction de cas de commutation imbriquée

Nous pouvons utiliser autant d’instructions switch que nous le souhaitons dans une instruction switch. Ce type d’instructions est appelé instructions de cas de commutation imbriquées. Considérez l'exemple suivant.

 #include int main () { int i = 10; int j = 20; switch(i) { case 10: printf('the value of i evaluated in outer switch: %d
',i); case 20: switch(j) { case 20: printf('The value of j evaluated in nested switch: %d
',j); } } printf('Exact value of i is : %d
', i ); printf('Exact value of j is : %d
', j ); return 0; }

Sortir 

 the value of i evaluated in outer switch: 10 The value of j evaluated in nested switch: 20 Exact value of i is : 10 Exact value of j is : 20

Avantages de l'instruction switch :

Il existe plusieurs avantages du instruction de commutation en C. Certains principaux avantages de l'instruction switch sont les suivants :

    Lisibilité et clarté :Le instruction de commutation fournit une manière concise et simple d'exprimer branchement multidirectionnel dans le code. Le traitement de plusieurs cas peut rendre le code plus organisé et plus facile à lire que plusieurs cas. instructions if-else imbriquées .Efficacité:Le instruction de commutation est généralement plus efficace qu’une série de déclarations if-else lorsqu’il s’agit de plusieurs conditions. Cela fonctionne comme un d table de saut direct , ce qui le rend plus rapide et plus optimisé en termes de temps d'exécution.Logique basée sur les cas :Le instruction de commutation convient naturellement aux scénarios dans lesquels le programme doit prendre des décisions basées sur les valeurs spécifiques d'une seule variable. Il s'agit d'un moyen intuitif et simple de mettre en œuvre une logique basée sur les cas.

Le instruction de commutation prend en charge l'utilisation d'un cas par défaut qui sert de option fourre-tout pour les valeurs qui ne correspondent à aucun des cas fournis. Ce cas par défaut gère les entrées inhabituelles ou les circonstances qui ne sont pas expressément indiquées.

Inconvénients de l'instruction switch :

Il existe plusieurs inconvénients du instruction de commutation en C. Certains principaux inconvénients de l'instruction switch sont les suivants :

    Expressions limitées :L'expression utilisée dans le instruction de commutation doit donner lieu à une valeur intégrale (char, int, enum) ou un type de données compatible. Il ne peut pas gérer plus expressions complexes ou non constantes , limitant son la flexibilité dans certains scénarios.Impossibilité de comparer les gammes :Contrairement à déclarations if-else , le instruction de commutation ne peut pas gérer directement les plages de valeurs. Chaque cas dans l'instruction switch représente une valeur constante spécifique, ce qui rend difficile la gestion efficace d'une plage de valeurs.Aucune prise en charge des nombres à virgule flottante :Le instruction de commutation accepte seulement types intégraux (entiers) et les valeurs de énumérations ; il n'accepte pas les nombres à virgule flottante. Il ne gère pas types de données non intégraux comme entiers à virgule flottante , ce qui peut poser problème dans certaines circonstances.Comportement de chute : Changer les instructions avoir 'tomber dans' comportement par défaut qui implique que si un cas n'inclut pas de déclaration « pause » , l'exécution sera 'tomber dans' au bloc de cas suivant. S’il n’est pas géré correctement, cela peut entraîner un comportement indésirable.Code en double :Utilisant un instruction de commutation peut entraîner une duplication de code dans certaines circonstances, notamment lorsque de nombreux cas nécessitent les mêmes actions. S'il n'est pas correctement géré, cela peut entraîner une duplication de code.Les commutateurs imbriqués peuvent devenir complexes :Lorsqu'il s'agit de imbriqué instructions de commutation , le code peut devenir complexe et moins lisible. Cela peut nécessiter des efforts supplémentaires pour comprendre et maintenir de telles structures imbriquées.