switch…case in C (Switch Statement in C) avec exemples

Exemple de changement de casse en C

Le programme suivant 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

1. Dans le programme donné, nous avons expliqué avoir initialisé une variable num avec la valeur 8.
2. Une construction de commutateur 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 avoir exécuté le cas, le contrôle tombera hors du commutateur et le programme se terminera avec le résultat réussi en imprimant 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, on considère le programme suivant 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 le changement de casse en C, vous regroupez plusieurs cas avec des étiquettes uniques. Vous devez introduire une instruction break dans chaque cas pour créer un branchement à la fin d'une instruction switch.

Le cas par défaut facultatif s'exécute lorsqu'aucune autre correspondance n'est établie.

Nous considérons l'instruction switch suivante :

#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

En C, nous pouvons avoir un interrupteur interne intégré dans un interrupteur externe. De plus, les constantes de casse du commutateur interne et externe peuvent avoir des valeurs communes et sans aucun conflit.

Nous considérons le programme suivant que l'utilisateur doit taper son propre ID, si l'ID est valide il lui demandera d'entrer son mot de passe, si le mot de passe est correct le programme imprimera le nom de l'utilisateur, sinon, le programme imprimera Incorrect Mot de passe et si l'ID n'existe pas, le programme imprimera 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

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 entrée dans la variable ID. 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 la casse correspondante, un commutateur interne est utilisé pour comparer les valeurs saisies dans la variable password et exécuter les instructions liées à la casse correspondante (lorsque password==000).
4. Sinon, le changement de casse déclenchera la casse par défaut et imprimera le texte approprié concernant le plan du programme.

Pourquoi avons-nous besoin d'un étui Switch ?

Il y a un problème potentiel avec l'instruction if-else qui est que la complexité du programme augmente chaque fois que le nombre de chemins alternatifs augmente. Si vous utilisez plusieurs constructions if-else dans le programme, un programme peut devenir difficile à lire et à comprendre. Parfois, cela peut même confondre 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 libellés de casse doivent se terminer par deux-points ( :).
• Un mot-clé de rupture doit être présent dans chaque cas.
• Il ne peut y avoir qu'un seul libellé par défaut.
• Nous pouvons imbriquer plusieurs instructions switch.

Résumé

• Un commutateur est une construction de prise de décision en "C".
• Un commutateur est utilisé dans un programme impliquant plusieurs décisions.
• Un commutateur doit contenir une expression de test exécutable.
• Chaque cas doit inclure un mot-clé de rupture.
• Le libellé de cas doit être constant et unique.
• La valeur par défaut est facultative.
• Plusieurs instructions switch peuvent être imbriquées les unes dans les autres.