L'instruction Switch case évalue une expression donnée et, en fonction de la valeur évaluée (correspondant à une certaine condition), elle exécute les instructions qui lui sont associées. Fondamentalement, il est utilisé pour effectuer différentes actions en fonction de différentes conditions (cas).

• Les instructions Switch Case suivent un mécanisme de contrôle de sélection et permettent à une valeur de modifier le contrôle de l'exécution.
• Ils remplacent longtemps si les déclarations qui comparent une variable à plusieurs valeurs intégrales.
• L'instruction switch est une instruction de branchement multidirectionnel. Il fournit un moyen simple de répartir l’exécution vers différentes parties du code en fonction de la valeur de l’expression.

En C, l'instruction switch case est utilisée pour exécuter une condition à partir de plusieurs conditions. C’est similaire à une échelle if-else-if.

Linux changer le nom du répertoire

L'instruction switch se compose de cas conditionnels et d'un cas par défaut.

Syntaxe de l'instruction switch en C

  switch(expression)     {     case   value1  :   statement_1;   break;     case   value2  :   statement_2;   break;   . . .   case   value_n  :   statement_n;   break;     default:   default_statement; }>

Comment utiliser l'instruction switch case en C ?

Avant d'utiliser le cas switch dans notre programme, nous devons connaître certaines règles de l'instruction switch.

Règles de la déclaration de cas de changement

Voici quelques-unes des règles que nous devons suivre lors de l'utilisation de l'instruction switch :

1. Dans une instruction switch, le valeur du cas doit être de carboniser et int taper.
2. Il peut y avoir un ou N cas.
3. Les valeurs dans le cas doivent être unique .
4. Chaque instruction du cas peut avoir une instruction break. C'est facultatif.
5. L'instruction par défaut est également facultative.

Exemple

// C program to Demonstrate returning of day based numeric // value #include  int main() {  // switch variable  int var = 1;  // switch statement  switch (var) {  case 1:  printf('Case 1 is Matched.');  break;  case 2:  printf('Case 2 is Matched.');  break;  case 3:  printf('Case 3 is Matched.');  break;  default:  printf('Default case is Matched.');  break;  }  return 0; }>

Case 1 is Matched.>

Comment fonctionne l'instruction switch ?

Le fonctionnement de l’instruction switch en C est le suivant :

1. Étape 1: La variable de commutation est évaluée.
2. Étape 2: La valeur évaluée est comparée à tous les cas présents.
3. Étape 3A : Si la valeur de cas correspondante est trouvée, le code associé est exécuté.
4. Étape 3B : Si le code correspondant n'est pas trouvé, alors le cas par défaut est exécuté s'il est présent.
5. Étape 4A : Si le mot-clé break est présent dans le cas, alors le contrôle du programme sort de l'instruction switch.
6. Étape 4B : Si le mot-clé break n'est pas présent, alors tous les cas après le cas correspondant sont exécutés.
7. Étape 5 : Les instructions après l'instruction switch sont exécutées.

Nous pouvons également comprendre le fonctionnement de l’instruction switch en C à l’aide de l’organigramme.

Organigramme de l'instruction Switch

Organigramme de l'instruction switch en C

Rupture dans le boîtier de l'interrupteur

Ce mot-clé est utilisé pour arrêter l'exécution à l'intérieur d'un bloc switch. Cela aide à terminer le bloc de commutation et à en sortir. Lorsqu'une instruction break est atteinte, le switch se termine et le flux de contrôle passe à la ligne suivante suivant l'instruction switch.

Le L'instruction break est facultative . En cas d'omission, l'exécution se poursuivra dans le cas suivant. Le flux de contrôle se répercutera sur les cas suivants jusqu'à ce qu'une rupture soit atteinte.

Exemple de boîtier d'interrupteur sans rupture

// C Program to demonstrate the behaviour of switch case // without break #include  int main() {  int var = 2;  // switch case without break  switch (var) {  case 1:  printf('Case 1 is executed.
');  case 2:  printf('Case 2 is executed.
');  case 3:  printf('Case 3 is executed.');  case 4:  printf('Case 4 is executed.');  }  return 0; }>

Case 2 is executed. Case 3 is executed.Case 4 is executed.>

Par défaut dans le cas du commutateur

Le mot-clé par défaut est utilisé pour spécifier l'ensemble de instructions à exécuter s'il n'y a pas de correspondance de cas .

C'est facultatif pour utiliser le mot-clé par défaut dans un cas de commutation. Même si l'instruction switch case n'a pas d'instruction par défaut, elle s'exécutera sans aucun problème.

Points importants concernant les instructions de cas de commutation

1. L'expression de commutation devrait entraîner un valeur constante

Si l’expression fournie dans l’instruction switch ne donne pas une valeur constante, elle ne sera pas valide. Certaines expressions valides pour le cas de commutation seront,

haricot java

// Constant expressions allowed switch(1+2+23) switch(1*2+3%4) // Variable expression are allowed provided // they are assigned with fixed values switch(a*b+c*d) switch(a+b+c)>

2. La valeur de l'expression doit être uniquement de type int ou char.

L'instruction switch ne peut évaluer que la valeur entière ou le caractère. L’expression switch doit donc renvoyer uniquement les valeurs de type int ou char.

3. Les valeurs de cas doivent être uniques

Dans l'instruction C switch, les valeurs de cas en double ne sont pas autorisées.

3. Imbrication des instructions switch

L'imbrication des instructions switch est autorisée , ce qui signifie que vous pouvez avoir des instructions switch dans un autre commutateur. Cependant, les instructions switch imbriquées doivent être évitées car elles rendent le programme plus complexe et moins lisible.

4. Le bloc par défaut peut être placé n'importe où

Quel que soit son emplacement, le cas par défaut n'est exécuté que si aucune des autres conditions du cas n'est remplie. Ainsi, le placer au début, au milieu ou à la fin ne change pas la logique fondamentale.

Exemples d'instruction switch en C

Exemple 1 : Programme C pour imprimer le jour de la semaine à l'aide d'un boîtier de commutation.

// C program to print the day using switch #include  // Driver Code int main() {  int day = 2;  printf('The day with number %d is ', day);  switch (day) {  case 1:  printf('Monday');  break;  case 2:  printf('Tuesday');  break;  case 3:  printf('Wednesday');  break;  case 4:  printf('Thursday');  break;  case 5:  printf('Friday');  break;  case 6:  printf('Saturday');  break;  case 7:  printf('Sunday');  break;  default:  printf('Invalid Input');  break;  }  return 0; }>

The day with number 2 is Tuesday>

Exemple 2 : Calculatrice simple utilisant un cas de commutation en C

// C Program to create a simple calculator using switch // statement #include  #include  // driver code int main() {  // switch variable  char choice;  // operands  int x, y;  while (1) {  printf('Enter the Operator (+,-,*,/)
Enter x to '  'exit
');  scanf(' %c', &choice);  // for exit  if (choice == 'x') {  exit(0);  }  printf('Enter the two numbers: ');  scanf('%d %d', &x, &y);  // switch case with operation for each operator  switch (choice) {  case '+':  printf('%d + %d = %d
', x, y, x + y);  break;  case '-':  printf('%d - %d = %d
', x, y, x - y);  break;  case '*':  printf('%d * %d = %d
', x, y, x * y);  break;  case '/':  printf('%d / %d = %d
', x, y, x / y);  break;  default:  printf('Invalid Operator Input
');  }  }  return 0; }>

Sortir

Enter the operator (+, -, *, /) Enter x to exit + Enter the two numbers: 100 + 200 100 + 200 = 300>

Avantages de la déclaration du commutateur C

1. Plus facile à lire que if else if.
2. Plus facile à déboguer et à maintenir pour un grand nombre de conditions.
3. Vitesse d'exécution plus rapide.

Inconvénients de la déclaration du commutateur C

1. Le cas de commutation ne peut évaluer que le type int ou char.
2. Aucune prise en charge des expressions logiques.
3. Il faut garder à l’esprit d’ajouter une pause dans tous les cas.

Conclusion

Dans cet article, nous avons discuté de l'instruction switch en programmation C et de la façon de l'utiliser. Il s'agit d'une déclaration conditionnelle comme l'échelle si-sinon-si ayant ses propres avantages et inconvénients. Cette méthode est particulièrement préférable lorsque le nombre de conditions à évaluer est important.

FAQ sur la déclaration du commutateur C

1. Quel est le cas de commutation en C ?

L'instruction switch case est une instruction de contrôle de flux dans laquelle nous pouvons définir une variable switch, puis exécuter un code différent en fonction de la valeur de la variable switch. C'est une alternative à if else if échelle.

2. Quel est le cas dans l’instruction switch en C ?

Le mot-clé case permet de définir les différents cas et leur code associé dans l'instruction switch.

3. À quoi sert la cassure du boîtier de l'interrupteur ?

Le mot-clé break est utilisé pour quitter le bloc switch après avoir exécuté le cas correspondant.

4. Quelles sont les différences entre switch et if else if ladder en C ?

Voici les principaux différences entre le commutateur C et C si sinon si échelle :

Doit lire:

• Faits intéressants sur le cas Switch en C
• Imprimer des chiffres individuels sous forme de mots sans utiliser if ou Switch