comutați...case în C (Switch Statement în C) cu Exemple

Ce este Declarația Switch în C?

Instrucțiunea Switch în C testează valoarea unei variabile și o compară cu mai multe cazuri. Odată ce se găsește potrivirea cazului, se execută un bloc de instrucțiuni asociate cu acel caz particular.

Fiecare caz dintr-un bloc al unui comutator are un nume/număr diferit, care este denumit un identificator. Valoarea furnizată de utilizator este comparată cu toate cazurile din interiorul blocului de comutare până când se găsește potrivirea.

Dacă NU este găsită o potrivire de caz, atunci instrucțiunea implicită este executată și controlul iese din blocul de comutare.

Comutați sintaxa majusculelor

O sintaxă generală a modului în care switch-case este implementată într-un program „C” este următoarea:

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;

• Expresia poate fi o expresie întreagă sau o expresie de caracter.
• Valoarea-1, 2, n sunt etichete de caz care sunt folosite pentru a identifica fiecare caz individual. Amintiți-vă că etichetele de caz nu ar trebui să fie aceleași, deoarece ar putea crea o problemă în timpul executării unui program. Să presupunem că avem două cazuri cu aceeași etichetă ca „1”. Apoi, în timpul executării programului, cazul care apare primul va fi executat chiar dacă doriți ca programul să execute un al doilea caz. Acest lucru creează probleme în program și nu oferă rezultatul dorit.
• Etichetele cazurilor se termină întotdeauna cu două puncte ( : ). Fiecare dintre aceste cazuri este asociat cu un bloc.
• Un bloc nu este altceva decât mai multe instrucțiuni care sunt grupate pentru un anumit caz.
• Ori de câte ori se execută comutatorul, valoarea expresiei test este comparată cu toate cazurile pe care le-am definit în interiorul comutatorului. Să presupunem că expresia de test conține valoarea 4. Această valoare este comparată cu toate cazurile până la caz a cărui etichetă patru este găsită în program. De îndată ce este găsit un caz, blocul de instrucțiuni asociat cu acel caz particular este executat și controlul iese din comutator.
• Cuvântul cheie break indică în fiecare caz sfârșitul unui anumit caz. Dacă nu punem pauză în fiecare caz, atunci chiar dacă cazul specific este executat, comutatorul din C va continua să execute toate cazurile până când se ajunge la final. Acest lucru nu ar trebui să se întâmple; prin urmare, trebuie să punem întotdeauna cuvântul cheie break în fiecare caz. Break va încheia cazul odată ce acesta este executat și controlul va cădea din comutator.
• Cazul implicit este unul opțional. Ori de câte ori valoarea expresiei de testare nu se potrivește cu niciunul dintre cazurile din interiorul comutatorului, atunci implicit va fi executat. În caz contrar, nu este necesar să scrieți implicit în comutator.
• Odată ce comutatorul este executat, controlul va merge la instrucțiunea-x, iar execuția unui program va continua.

Diagramă de flux al declarației de comutare

Următoarea diagramă ilustrează cum este selectată un caz în cazul comutatorului:

Cum funcționează Switch

Exemplu de comutare a cazului în C

Următorul program ilustrează utilizarea comutatorului:

#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;
    }

ieșire:

Value is 8

1. În programul dat am inițializat un variabil num cu valoarea 8.
2. O construcție de comutare este utilizată pentru a compara valoarea stocată în variabila num și pentru a executa blocul de instrucțiuni asociate cu cazul potrivit.
3. În acest program, deoarece valoarea stocată în variabila num este opt, un comutator va executa cazul a cărui etichetă de caz este 8. După executarea cazului, controlul va cădea din comutator și programul va fi terminat cu rezultatul de succes prin imprimarea valorii pe ecranul de ieșire.

Încercați să modificați valoarea variabilei num și observați modificarea rezultatului.

De exemplu, luăm în considerare următorul program care este implicit:

#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");}}

ieșire:

Other programming language

Când lucrați cu comutatorul casei în C, grupați mai multe cazuri cu etichete unice. Trebuie să introduceți o instrucțiune break în fiecare caz pentru a se ramifica la sfârșitul unei instrucțiuni switch.

Cazul implicit opțional rulează atunci când nu se fac alte potriviri.

Luăm în considerare următoarea declarație de comutare:

#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");}}

ieșire:

Four, Five, or Six.

Comutator imbricat în C

In C, putem avea un comutator interior încorporat într-un comutator exterior. De asemenea, constantele de caz ale comutatorului interior și exterior pot avea valori comune și fără conflicte.

Considerăm următorul program, care solicită utilizatorului să își introducă propriul ID. Dacă ID-ul este valid, acesta va solicita introducerea parolei; dacă parola este corectă, programul va afișa numele utilizatorului, altfel va afișa Parolă incorectă; iar dacă ID-ul nu există, programul va afișa ID incorect.

#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;
        }
}

ieșire:

Plese Enter Your ID:
 500
Enter your password:
 000
Welcome Dear Programmer

1. În programul dat am inițializat două variabile: ID-ul și parola.
2. O construcție de comutare externă este utilizată pentru a compara valoarea introdusă în variabila ID. Aceasta execută blocul de instrucțiuni asociat cazului potrivit (când ID==500).
3. Dacă instrucțiunea bloc este executată cu cazul potrivit, se utilizează un comutator intern pentru a compara valorile introduse în variabila password și a executa instrucțiunile legate de cazul potrivit (când password==000).
4. În caz contrar, cazul comutatorului va declanșa cazul implicit și va tipări textul corespunzător cu privire la schița programului.

De ce avem nevoie de o carcasă Switch?

Există o problemă potențială cu declarație dacă-altfel care este complexitatea programului crește ori de câte ori crește numărul de căi alternative. Dacă utilizați mai multe constructe if-else în program, un program poate deveni dificil de citit și de înțeles. Uneori poate chiar deruta dezvoltatorul care a scris el însuși programul.

Soluția la această problemă este declarația switch.

Reguli pentru declarația de comutare

Urmați aceste reguli atunci când scrieți un switch în C:

• O expresie trebuie să se execute întotdeauna la un rezultat.
• Etichetele cazului trebuie să fie constante și unice.
• Etichetele de caz trebuie să se încheie cu două puncte ( : ).
• Un cuvânt cheie break trebuie să fie prezent în fiecare caz.
• Poate exista o singură etichetă implicită.
• Putem imbrica mai multe instrucțiuni switch.

Întrebări frecvente