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

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:

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 explicat inițializat a 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.

Luăm în considerare următorul program în care utilizatorul să-și introducă propriul ID, dacă ID-ul este valid îi va cere să introducă parola, dacă parola este corectă programul va tipări numele utilizatorului, în caz contrar, programul va tipări Incorect Parola și dacă ID-ul nu există, programul va imprima 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 explicat inițializate două variabile: ID și parola
2. Un construct de comutator exterior este utilizat pentru a compara valoarea introdusă în ID-ul variabilei. Execută blocul de instrucțiuni asociat cu cazul potrivit (când ID==500).
3. Dacă instrucțiunea de bloc este executată cu majusculele potrivite, se folosește un comutator intern pentru a compara valorile introduse în parola variabilei și pentru a executa instrucțiunile legate de majusculele potrivite (când parola==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

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

Rezumat

• Un comutator este o construcție de luare a deciziilor în "C
• Un comutator este utilizat într-un program în care sunt implicate mai multe decizii.
• Un comutator trebuie să conțină o expresie de testare executabilă.
• Fiecare caz trebuie să includă un cuvânt cheie break.
• Eticheta cazului trebuie să fie constante și unică.
• Valoarea implicită este opțională.
• Mai multe instrucțiuni switch pot fi imbricate una în alta.