La sentència switch en C és una declaració alternativa a la instrucció d'escala if-else-if que ens permet executar diverses operacions per als diferents valors possibles d'una sola variable anomenada variable switch. Aquí, podem definir diverses declaracions en els casos múltiples per als diferents valors d'una sola variable.

La sintaxi de la instrucció switch in c llengua es dóna a continuació:

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

Regles per a la declaració switch en llenguatge C

1. El canviar l'expressió ha de ser d'un tipus enter o caràcter.
2. El valor de cas ha de ser una constant enter o caràcter.
3. El valor de cas només es pot utilitzar dins de la instrucció switch.
4. El declaració de ruptura en cas de canvi no és necessari. És opcional. Si no es troba cap declaració de ruptura en el cas, tots els casos s'executaran presents després del cas coincident. Es coneix com caure a través l'estat de la declaració de commutació C.

Intentem entendre-ho amb exemples. Suposem que hi ha les següents variables.

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

Diagrama de flux de la declaració de commutació en C

Funcionament de la declaració de cas de commutació

En primer lloc, s'avalua l'expressió entera especificada a la instrucció switch. Aquest valor es fa coincidir un per un amb els valors constants donats en els diferents casos. Si es troba una coincidència, s'executen totes les declaracions especificades en aquest cas juntament amb tots els casos presents després d'aquest cas, inclosa la instrucció per defecte. No hi ha dos casos que tinguin valors semblants. Si el cas coincident conté una instrucció break, es saltaran tots els casos presents després d'això i el control surt de l'interruptor. En cas contrari, s'executaran tots els casos següents al cas coincident.

Com funciona la declaració C switch?

Anem a seguir el procés pas a pas de com funciona la instrucció switch a C:

Considereu el següent declaració de commutació :

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

Sortida

 Value is 2 

Procés pas a pas:

1. El canvi variable núm s'avalua. En aquest cas, en una s'inicia amb el valor 2 .
2. El valor avaluat num (2). es compara amb les constants especificades a l'etiqueta de cada cas dins del fitxer bloc de commutació .
3. El declaració de commutació coincideix amb el valor avaluat (2) amb la constant especificada a segon cas (cas 2) . Com que hi ha una coincidència, el programa salta al bloc de codi associat amb el cas coincident (cas 2) .
4. El bloc de codi associat amb cas 2 s'executa, que imprimeix 'El valor és 2' a la consola.
5. El 'trencar' La paraula clau està present al bloc de codi de cas 2 . Com a resultat, el programa surt de la instrucció switch immediatament després d'executar el bloc de codi.
6. El control del programa continua després de declaració de commutació , i les declaracions posteriors a declaració de commutació s'executen. En aquest cas, no hi ha declaracions després del canvi, de manera que el programa finalitza.
7. El declaració de commutació avaluat el valor de la variable núm , va trobar una coincidència amb el cas 2, va executar el bloc de codi corresponent i després va sortir de l' bloc de commutació a causa de la presència de la declaració 'trencar' .

Exemple d'una sentència switch en C

Vegem un exemple senzill d'una declaració de canvi de llenguatge 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; } 

Sortida

node de llista java

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

Exemple 2 de canvi de cas

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

Sortida

 hi 

Pausa i paraula clau predeterminada a la declaració Switch

Expliquem i definim el 'trencar' i paraules clau 'predeterminades'. en el context de la instrucció switch, juntament amb el codi d'exemple i la sortida.

1. Trenca paraula clau:

El paraula clau 'trencar' s'utilitza dins del bloc de codi de cada cas per finalitzar prematurament la instrucció switch. Quan el programa troba a declaració 'trencar' dins d'un bloc de caixa, surt immediatament del declaració de commutació , impedint l'execució de blocs de casos posteriors. El declaració 'trencar' és crucial per evitar declaracions de commutació' 'caiguda' comportament.

Exemple:

Prenem un programa per entendre l'ús de la la paraula clau trenca en 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; } 

Sortida

 Value is 3 

Explicació:

En aquest exemple, el declaració de commutació avalua el valor de la variable núm (el qual és 3 ) i el coincideix amb cas 3 . El bloc de codi associat amb cas 3 s'executa, imprimint 'El valor és 3' a la consola. El declaració 'trencar' dins cas 3 assegura que el programa surt de la instrucció switch immediatament després d'executar aquest bloc de casos, evitant l'execució de qualsevol altre cas.

2. Paraula clau predeterminada:

Quan cap dels constants de cas coincideix amb el expressió avaluada , funciona com a cas general . Si no existeix cap cas coincident i a El cas 'predeterminat' existeix , el bloc de codi associat amb el 'per defecte' s'executa el cas. Sovint s'utilitza per gestionar circumstàncies en què cap de les situacions indicades s'aplica a l'entrada proporcionada.

Exemple:

Prenem un programa per entendre l'ús de la paraula clau predeterminada en 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; } 

Sortida

 Value is not 1, 2, or 3 

Explicació:

En aquest exemple, el declaració de commutació examina el valor de la variable núm (el qual és 5 ). Com que cap cas coincideix amb el num, el programa realitza el bloc de codi associat amb el cas 'predeterminat'. . El declaració 'trencar' dins del cas 'predeterminat'. assegura que el programa surt de declaració de commutació després d'executar el 'per defecte' bloc de casos.

Tant el 'trencar' i paraules clau 'predeterminades'. tenen un paper essencial en el control del flux d'execució dins d'una instrucció switch. El declaració 'trencar' ajuda a prevenir el comportament de caiguda, mentre que el cas 'predeterminat'. ofereix una manera de gestionar casos incomparables.

La declaració C Switch és caiguda

En llenguatge C, la declaració switch és fallida; vol dir que si no utilitzeu una instrucció break al cas switch, s'executaran tots els casos posteriors al cas coincident.

Intentem entendre l'estat de caiguda de la declaració de commutació amb l'exemple que es mostra a continuació.

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

Sortida

 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 

Sortida

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

Declaració de cas de commutació niuada

Podem utilitzar tantes declaracions switch com vulguem dins d'una instrucció switch. Aquest tipus d'instruccions s'anomenen declaracions de cas de commutació imbricades. Considereu l'exemple següent.

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

Sortida

 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 

Avantatges de la declaració switch:

Hi ha diversos avantatges del declaració de commutació a C. Alguns avantatges principals de la instrucció switch són els següents:

Llegibilitat i claredat:El declaració de commutació ofereix una manera concisa i senzilla d'expressar-se ramificació multidireccional al codi. Tractar diversos casos pot fer que el codi sigui més organitzat i més fàcil de llegir que no pas diversos declaracions if-else imbricades .Eficiència:El declaració de commutació generalment és més eficient que una sèrie de declaracions if-else quan es tracta de múltiples condicions. Funciona com a d taula de salt directe , que el fa més ràpid i optimitzat pel que fa al temps d'execució.Lògica basada en casos:El declaració de commutació s'adapta naturalment a escenaris en què el programa necessita prendre decisions basant-se en valors específics d'una sola variable. És una manera intuïtiva i senzilla d'implementar la lògica basada en casos.

El declaració de commutació admet l'ús d'un cas predeterminat que serveix com a opció general per als valors que no coincideixen amb cap cas proporcionat. Això cas predeterminat gestiona entrades o circumstàncies inusuals que no s'indiquen expressament.

Desavantatges de la declaració switch:

Hi ha diversos desavantatges del declaració de commutació a C. Alguns desavantatges principals de la instrucció switch són els següents:

Expressions limitades:L'expressió utilitzada en el declaració de commutació ha de donar lloc a un valor integral (char, int, enumeració) o un tipus de dades compatible. No es pot gestionar més Expressions complexes o no constants , limitant-ne flexibilitat en alguns escenaris.Incapacitat per comparar intervals:A diferència declaracions if-else , el declaració de commutació no pot gestionar els intervals de valors directament. Cada cas de la declaració de commutació representa un valor constant específic, cosa que fa que sigui difícil gestionar una sèrie de valors de manera eficient.No hi ha suport per als números de coma flotant:El declaració de commutació només accepta tipus integrals (nters) i valors de enumeracions ; no accepta nombres de coma flotant. No maneja tipus de dades no integrals M'agrada nombres enters de coma flotant , que pot ser problemàtic en algunes circumstàncies.Comportament de caiguda: Declaracions de canvi tenir 'caiguda' comportament per defecte que implica que si un cas no inclou a declaració 'trencar' , execució serà 'caure' al bloc de casos següent. Si no es gestiona adequadament, això podria provocar un comportament no desitjat.Codi duplicat:Utilitzant a declaració de commutació pot donar lloc a codi duplicat en algunes circumstàncies, especialment quan molts casos exigeixen les mateixes accions. Si no es gestiona correctament, això podria provocar la duplicació del codi.Els interruptors nius poden arribar a ser complexos:Quan es tracta niat declaracions de commutació , el codi pot arribar a ser complex i menys llegible. Pot requerir un esforç addicional per comprendre i mantenir aquestes estructures imbricades.