L'istruzione switch in C è un'alternativa all'istruzione ladder if-else-if che ci consente di eseguire più operazioni per i diversi valori possibili di una singola variabile chiamata variabile switch. Qui, possiamo definire varie affermazioni in più casi per i diversi valori di una singola variabile.

La sintassi dell'istruzione switch in lingua c è riportato di seguito:

 switch(expression){ case value1: //code to be executed; break; //optional case value2: //code to be executed; break; //optional ...... default: code to be executed if all cases are not matched; } 

Regole per l'istruzione switch in linguaggio C

1. IL cambiare espressione deve essere di tipo intero o carattere.
2. IL valore del caso deve essere un numero intero o una costante di carattere.
3. IL valore del caso può essere utilizzato solo all'interno dell'istruzione switch.
4. IL interrompere l'istruzione nel caso dell'interruttore non è necessario. È facoltativo. Se nel caso non viene trovata alcuna istruzione break, tutti i casi verranno eseguiti dopo il caso corrispondente. È noto come sfumare lo stato dell'istruzione switch C.

Proviamo a capirlo con gli esempi. Supponiamo che ci siano le seguenti variabili.

 int x,y,z; char a,b; float f; 

Diagramma di flusso dell'istruzione switch in C

Funzionamento dell'istruzione switch case

Innanzitutto viene valutata l'espressione intera specificata nell'istruzione switch. Questo valore viene poi confrontato uno per uno con i valori costanti forniti nei diversi casi. Se viene trovata una corrispondenza, tutte le istruzioni specificate in quel caso vengono eseguite insieme a tutti i casi presenti dopo quel caso, inclusa l'istruzione predefinita. Non esistono due casi che possono avere valori simili. Se il caso corrispondente contiene un'istruzione break, tutti i casi presenti dopo verranno saltati e il controllo esce dallo switch. In caso contrario, verranno eseguiti tutti i casi successivi al caso abbinato.

Come funziona l'istruzione C switch?

Esaminiamo passo dopo passo il funzionamento dell'istruzione switch in C:

Considera quanto segue dichiarazione di cambio :

Programma C:

 #include int main() { int num = 2; switch (num) { case 1: printf('Value is 1
'); break; case 2: printf('Value is 2
'); break; case 3: printf('Value is 3
'); break; default: printf('Value is not 1, 2, or 3
'); break; } return 0; } 

Produzione

 Value is 2 

Procedura dettagliata:

1. IL cambia variabile num viene valutato. In questo caso, nessuno viene inizializzato con il valore 2 .
2. IL valore num (2) valutato viene confrontato con le costanti specificate in ogni etichetta all'interno del file blocco interruttore .
3. IL dichiarazione di cambio corrisponde a valore valutato (2) con la costante specificata nel secondo caso (caso 2) . Poiché esiste una corrispondenza, il programma passa al blocco di codice associato al file caso corrispondente (caso 2) .
4. Il blocco di codice associato a caso 2 viene eseguito, che stampa 'Il valore è 2' alla consolle.
5. IL 'rottura' la parola chiave è presente nel blocco di codice di caso 2 . Di conseguenza, il programma esce dall'istruzione switch immediatamente dopo l'esecuzione del blocco di codice.
6. Il controllo del programma continua dopo dichiarazione di cambio e qualsiasi dichiarazione successiva al dichiarazione di cambio vengono eseguiti. In questo caso non ci sono istruzioni dopo lo switch, quindi il programma termina.
7. IL dichiarazione di cambio valutato il valore del numero variabile , ha trovato una corrispondenza con il caso 2, ha eseguito il blocco di codice corrispondente e quindi è uscito dal blocco interruttore per la presenza del dichiarazione di 'interruzione'. .

Esempio di istruzione switch in C

Vediamo un semplice esempio di un'istruzione di cambio del linguaggio C.

 #include int main(){ int number=0; printf('enter a number:'); scanf('%d',&number); switch(number){ case 10: printf('number is equals to 10'); break; case 50: printf('number is equal to 50'); break; case 100: printf('number is equal to 100'); break; default: printf('number is not equal to 10, 50 or 100'); } return 0; } 

Produzione

mvc con java

 enter a number:4 number is not equal to 10, 50 or 100 enter a number:50 number is equal to 50 

Esempio di caso di commutazione 2

 #include int main() { int x = 10, y = 5; switch(x>y && x+y>0) { case 1: printf('hi'); break; case 0: printf('bye'); break; default: printf(' Hello bye '); } } 

Produzione

 hi 

Parole chiave Break e Default nell'istruzione Switch

Spieghiamo e definiamo il 'rottura' E parole chiave 'predefinite'. nel contesto dell'istruzione switch, insieme al codice di esempio e all'output.

1. Interrompi la parola chiave:

IL parola chiave 'interruzione'. viene utilizzato all'interno del blocco di codice di ciascun caso per terminare prematuramente l'istruzione switch. Quando il programma incontra a dichiarazione di 'interruzione'. all'interno di un blocco case, esce immediatamente dal dichiarazione di cambio , impedendo l'esecuzione dei successivi blocchi di casi. IL dichiarazione di 'interruzione'. è fondamentale per evitare dichiarazioni di cambio' 'sfumare' comportamento.

Esempio:

Prendiamo un programma per comprendere l'uso del file interrompere la parola chiave in C.

 #include int main() { int num = 3; switch (num) { case 1: printf('Value is 1
'); break; // Exit the switch statement after executing this case block case 2: printf('Value is 2
'); break; // Exit the switch statement after executing this case block case 3: printf('Value is 3
'); break; // Exit the switch statement after executing this case block default: printf('Value is not 1, 2, or 3
'); break; // Exit the switch statement after executing the default case block } return 0; } 

Produzione

 Value is 3 

Spiegazione:

In questo esempio, il dichiarazione di cambio valuta il valore di numero variabile (che è 3 ) e lo abbina a caso 3 . Il blocco di codice associato a caso 3 viene eseguito, stampando 'Il valore è 3' alla consolle. IL dichiarazione di 'interruzione'. entro caso 3 assicura che il programma esca dall'istruzione switch immediatamente dopo aver eseguito questo blocco case, impedendo l'esecuzione di qualsiasi altro case.

2. Parola chiave predefinita:

Quando nessuno dei costanti del caso abbinare la espressione valutata , funziona come a caso generale . Se non esiste alcun caso corrispondente e a Esiste il caso 'predefinito'. , il blocco di codice associato a 'predefinito' il caso viene eseguito. Viene spesso utilizzato per gestire circostanze in cui nessuna delle situazioni indicate si applica all'input fornito.

Esempio:

Prendiamo un programma per comprendere l'uso del file parola chiave predefinita in C.

 #include int main() { int num = 5; switch (num) { case 1: printf('Value is 1
'); break; case 2: printf('Value is 2
'); break; case 3: printf('Value is 3
'); break; default: printf('Value is not 1, 2, or 3
'); break; // Exit the switch statement after executing the default case block } return 0; } 

Produzione

 Value is not 1, 2, or 3 

Spiegazione:

In questo esempio, il dichiarazione di cambio esamina il valore del numero variabile (che è 5 ). Poiché nessun caso corrisponde al num, il programma esegue il blocco di codice associato a caso 'predefinito'. . IL dichiarazione di 'interruzione'. dentro il caso 'predefinito'. assicura che il programma esca dal dichiarazione di cambio dopo aver eseguito il 'predefinito' blocco del caso.

Entrambi i 'rottura' E parole chiave 'predefinite'. svolgono un ruolo essenziale nel controllare il flusso di esecuzione all'interno di un'istruzione switch. IL dichiarazione di 'interruzione'. aiuta a prevenire il comportamento di caduta, mentre il caso 'predefinito'. fornisce un modo per gestire casi senza corrispondenza.

L'istruzione C Switch è fall-through

Nel linguaggio C, l'istruzione switch è fall through; significa che se non si utilizza un'istruzione break nel caso switch, verranno eseguiti tutti i casi successivi al caso corrispondente.

Proviamo a comprendere lo stato fall through dell'istruzione switch con l'esempio fornito di seguito.

 #include int main(){ int number=0; printf('enter a number:'); scanf('%d',&number); switch(number){ case 10: printf('number is equal to 10
'); case 50: printf('number is equal to 50
'); case 100: printf('number is equal to 100
'); default: printf('number is not equal to 10, 50 or 100'); } return 0; } 

Produzione

 enter a number:10 number is equal to 10 number is equal to 50 number is equal to 100 number is not equal to 10, 50 or 100 

Produzione

 enter a number:50 number is equal to 50 number is equal to 100 number is not equal to 10, 50 or 100 

Dichiarazione switch case nidificata

Possiamo usare quante istruzioni switch vogliamo all'interno di un'istruzione switch. Questo tipo di istruzioni è chiamato istruzioni switch case nidificate. Considera il seguente esempio.

 #include int main () { int i = 10; int j = 20; switch(i) { case 10: printf('the value of i evaluated in outer switch: %d
',i); case 20: switch(j) { case 20: printf('The value of j evaluated in nested switch: %d
',j); } } printf('Exact value of i is : %d
', i ); printf('Exact value of j is : %d
', j ); return 0; } 

Produzione

 the value of i evaluated in outer switch: 10 The value of j evaluated in nested switch: 20 Exact value of i is : 10 Exact value of j is : 20 

Vantaggi dell'istruzione switch:

Ci sono diversi vantaggi di dichiarazione di cambio in C. Alcuni vantaggi principali dell'istruzione switch sono i seguenti:

Leggibilità e chiarezza:IL dichiarazione di cambio fornisce un modo conciso e diretto per esprimersi ramificazione multidirezionale nel codice. Gestire più casi può rendere il codice più organizzato e più facile da leggere rispetto a più casi istruzioni if-else nidificate .Efficienza:IL dichiarazione di cambio è generalmente più efficiente di una serie di istruzioni if-else quando si ha a che fare con molteplici condizioni. Funziona come un d tabella di salto diretto , il che lo rende più veloce e ottimizzato in termini di tempi di esecuzione.Logica basata sui casi:IL dichiarazione di cambio si adatta naturalmente agli scenari in cui il programma deve prendere decisioni in base a valori specifici di una singola variabile. È un modo intuitivo e diretto per implementare la logica basata sui casi.

IL dichiarazione di cambio supporta l'utilizzo di un caso predefinito che funge da a opzione catch-all per valori che non corrispondono ad alcun caso fornito. Questo caso predefinito gestisce input o circostanze insoliti che non sono espressamente indicati.

Svantaggi dell'istruzione switch:

Ci sono diversi svantaggi di dichiarazione di cambio in C. Alcuni principali svantaggi dell'istruzione switch sono i seguenti:

Espressioni limitate:L'espressione usata nel dichiarazione di cambio deve risultare in un valore integrale (char, int, enum) o un tipo di dati compatibile. Non può gestire di più espressioni complesse o non costanti , limitandone la flessibilità in alcuni scenari.Impossibilità di confrontare gli intervalli:A differenza di istruzioni if-else , IL dichiarazione di cambio non può gestire direttamente intervalli di valori. Ogni caso nell'istruzione switch rappresenta un valore costante specifico, rendendo difficile gestire in modo efficiente un intervallo di valori.Nessun supporto per i numeri in virgola mobile:IL dichiarazione di cambio accetta solo tipi interi (interi) e valori da enumerazioni ; non accetta numeri in virgola mobile. Non gestisce tipi di dati non integrali Piace numeri interi in virgola mobile , che potrebbe essere problematico in alcune circostanze.Comportamento in caso di caduta: Scambia le dichiarazioni Avere 'sfumare' comportamento per impostazione predefinita, il che implica che se un caso non include a dichiarazione di 'interruzione'. , volontà di esecuzione 'sfumare' al blocco di casi successivo. Se non gestito in modo appropriato, ciò potrebbe causare comportamenti indesiderati.Codice duplicato:Usare un dichiarazione di cambio potrebbe causare la duplicazione del codice in alcune circostanze, soprattutto quando numerosi casi richiedono le stesse azioni. Se non gestito correttamente, ciò potrebbe causare la duplicazione del codice.Gli switch nidificati possono diventare complessi:Quando si ha a che fare con nidificato scambiare dichiarazioni , il codice può diventare complesso e meno leggibile. Potrebbe essere necessario uno sforzo aggiuntivo per comprendere e mantenere tali strutture annidate.