switch…cas en C (instruction Switch en C) avec exemples

Qu’est-ce que l’instruction Switch en C ?

Instruction de commutation en C teste la valeur d'une variable et compares avec plusieurs cas. Une fois la correspondance de cas trouvée, un bloc d'instructions associé à ce cas particulier 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

Following Le diagramme illustre comment un cas est sélectionné dans le cas de commutation :

Organigramme de l'instruction Switch
Comment fonctionne le commutateur

Exemple de cas de commutation en C

Following le programme 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

Exemple de cas de commutation en C

  1. Dans le programme donné, nous avons expliqué initialisé un variable num avec la valeur 8.
  2. 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.
  3. 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 suivantwing programme qui 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 le suivantwing instruction de commutation :

#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 suivantwing programme permettant à l'utilisateur de saisir son propre identifiant, si l'identifiant est valide, il lui demandera de saisir son mot de passe, si le mot de passe est correct, le programme imprimera le nom de l'utilisateur, sinon, le programme imprimera un mot de passe incorrect et si le L'ID n'existe pas, le programme imprimera un ID 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

Commutateur imbriqué en C

  1. Dans le programme donné, nous avons expliqué deux variables initialisées : ID et mot de passe
  2. Une construction de commutateur externe est utilisée pour comparer la valeur saisie dans l'ID de variable. Il exécute le bloc d'instructions associé au cas correspondant (quand ID==500).
  3. Si l'instruction de bloc est exécutée avec le cas correspondant, un commutateur interne est utilisé pour comparer les valeurs saisies dans la variable mot de passe et exécuter les instructions liées au cas correspondant (lorsque mot de passe == 000).
  4. 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 quel est le complexLa qualité 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

  • 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.

Résumé

  • Un changement est une construction de prise de décision dans 'C.
  • Un commutateur est utilisé dans un programme où plusieurs décisions sont impliquées.
  • Un commutateur doit contenir une expression de test exécutable.
  • Chaque cas doit inclure un mot-clé break.
  • L’étiquette du cas doit être constante et unique.
  • La valeur par défaut est facultative.
  • Plusieurs instructions switch peuvent être imbriquées les unes dans les autres.