De switch-instructie in C is een alternatief voor de if-else-if-ladder-instructie waarmee we meerdere bewerkingen kunnen uitvoeren voor de verschillende mogelijke waarden van een enkele variabele, de zogenaamde switch-variabele. Hier kunnen we verschillende uitspraken definiëren in de meerdere gevallen voor de verschillende waarden van een enkele variabele.

De syntaxis van de switch-instructie in c taal staat hieronder:

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

Regels voor switch-instructie in C-taal

1. De expressie wisselen moet van een geheel getal of tekentype zijn.
2. De zaak waarde moet een geheel getal of tekenconstante zijn.
3. De zaak waarde kan alleen binnen de switch-instructie worden gebruikt.
4. De verklaring breken in schakelkast is dit niet verplicht. Het is optioneel. Als er geen break-instructie in de case wordt gevonden, worden alle cases na de overeenkomende case uitgevoerd. Het is bekend als er doorheen vallen de status van C-switch-instructie.

Laten we proberen het te begrijpen aan de hand van de voorbeelden. We gaan ervan uit dat er de volgende variabelen zijn.

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

Stroomschema van switch-instructie in C

Werking van de switch case-instructie

Eerst wordt de gehele expressie die is opgegeven in de switch-instructie geëvalueerd. Deze waarde wordt vervolgens één voor één vergeleken met de constante waarden die in de verschillende gevallen zijn opgegeven. Als er een overeenkomst wordt gevonden, worden alle instructies die in dat geval zijn opgegeven, uitgevoerd samen met alle gevallen die na dat geval aanwezig zijn, inclusief de standaardinstructie. Geen twee gevallen kunnen vergelijkbare waarden hebben. Als het overeenkomende geval een break-instructie bevat, worden alle daarna aanwezige gevallen overgeslagen en komt de besturing uit de switch. Anders worden alle cases die volgen op de overeenkomende case uitgevoerd.

Hoe werkt de C-switch-instructie?

Laten we stapsgewijs doornemen hoe de switch-instructie werkt in C:

Stel je de volgende situatie voor schakel verklaring :

C-programma:

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

Uitvoer

 Value is 2 

Stapsgewijs proces:

1. De schakelvariabele num wordt geëvalueerd. In dit geval, op een wordt geïnitialiseerd met de waarde 2 .
2. De geëvalueerde getalwaarde (2). wordt vergeleken met de constanten die zijn opgegeven in elk caselabel in de schakel blok .
3. De schakel verklaring komt overeen met de geëvalueerde waarde (2) met de constante gespecificeerd in de tweede geval (geval 2) . Omdat er een overeenkomst is, springt het programma naar het codeblok dat bij de bijpassende koffer (zaak 2) .
4. Het codeblok dat is gekoppeld aan geval 2 wordt uitgevoerd, die wordt afgedrukt 'Waarde is 2' naar de console.
5. De 'pauze' trefwoord aanwezig is in het codeblok van geval 2 . Als gevolg hiervan breekt het programma onmiddellijk na het uitvoeren van het codeblok de switch-instructie af.
6. De programmabesturing gaat verder na de schakel verklaring , en alle verklaringen die volgen op de schakel verklaring worden geëxecuteerd. In dit geval zijn er geen instructies na de overstap, dus wordt het programma beëindigd.
7. De schakel verklaring evalueerde de waarde van de variabel getal , vond een overeenkomst met geval 2, voerde het overeenkomstige codeblok uit en verliet vervolgens het schakel blok door de aanwezigheid van 'breek'-verklaring .

Voorbeeld van een switch-instructie in C

Laten we een eenvoudig voorbeeld bekijken van een C-taalwisselinstructie.

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

Uitvoer

java booleaans

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

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

Uitvoer

 hi 

Break en Default trefwoord in Switch-instructie

Laten we het uitleggen en definiëren 'pauze' En 'standaard' zoekwoorden in de context van de switch-instructie, samen met voorbeeldcode en uitvoer.

1. Zoekwoord breken:

De trefwoord 'breken' wordt binnen het codeblok van elk geval gebruikt om de switch-instructie voortijdig te beëindigen. Wanneer het programma een 'breek'-verklaring binnen een casusblok verlaat het onmiddellijk de schakel verklaring , waardoor de uitvoering van volgende case-blokken wordt voorkomen. De 'breek'-verklaring is cruciaal om switch-statements te vermijden' 'doorval' gedrag.

Voorbeeld:

Laten we een programma nemen om het gebruik van de sleutelwoord breken 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; } 

Uitvoer

 Value is 3 

Uitleg:

In dit voorbeeld is de schakel verklaring evalueert de waarde van de variabel getal (dat is 3 ) en matcht ermee geval 3 . Het codeblok dat is gekoppeld aan geval 3 wordt uitgevoerd, afgedrukt 'Waarde is 3' naar de console. De 'breek'-verklaring binnenin geval 3 zorgt ervoor dat het programma de switch-instructie onmiddellijk verlaat na het uitvoeren van dit case-blok, waardoor de uitvoering van andere cases wordt voorkomen.

2. Standaardtrefwoord:

Wanneer geen van de gevalsconstanten overeenkomen met de geëvalueerde expressie , het werkt als een allesomvattend geval . Als er geen overeenkomend geval bestaat en a Er bestaat een 'standaard'-geval , het codeblok dat is gekoppeld aan de 'standaard' zaak wordt gelopen. Het wordt vaak gebruikt om omstandigheden aan te pakken waarin geen van de genoemde situaties van toepassing is op de verstrekte invoer.

Voorbeeld:

Laten we een programma nemen om het gebruik van de standaard trefwoord 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; } 

Uitvoer

 Value is not 1, 2, or 3 

Uitleg:

In dit voorbeeld is de schakel verklaring onderzoekt de waarde van de variabel getal (dat is 5 ). Omdat geen enkel hoofdlettergebruik overeenkomt met het getal, voert het programma het codeblok uit dat bij het 'standaard' geval . De 'breek'-verklaring binnen in de 'standaard' geval zorgt ervoor dat het programma de schakel verklaring na het uitvoeren van de 'standaard' kast blok.

Beide 'pauze' En 'standaard' zoekwoorden spelen een essentiële rol bij het beheersen van de uitvoeringsstroom binnen een switch-instructie. De 'breek'-verklaring helpt het doorvalgedrag te voorkomen, terwijl de 'standaard' geval biedt een manier om ongeëvenaarde gevallen af ​​te handelen.

C Switch-instructie is een fall-through

In de C-taal is de switch-instructie mislukt; het betekent dat als u geen break-instructie gebruikt in het switch-geval, alle gevallen na het overeenkomende geval zullen worden uitgevoerd.

Laten we proberen de fall-through-status van de switch-instructie te begrijpen aan de hand van het onderstaande voorbeeld.

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

Uitvoer

 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 

Uitvoer

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

Geneste switch case-instructie

We kunnen zoveel switch-instructies gebruiken als we willen in een switch-instructie. Dergelijke typen instructies worden geneste switch-case-instructies genoemd. Beschouw het volgende voorbeeld.

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

Uitvoer

 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 

Voordelen van de switchverklaring:

Er zijn verschillende voordelen van de schakel verklaring in C. Enkele belangrijke voordelen van de switch-instructie zijn als volgt:

Leesbaarheid en duidelijkheid:De schakel verklaring biedt een beknopte en eenvoudige manier om uit te drukken meerweg vertakking in de code. Als u met meerdere gevallen omgaat, kan de code overzichtelijker en gemakkelijker te lezen zijn dan bij meerdere gevallen geneste if-else-instructies .Efficiëntie:De schakel verklaring is over het algemeen efficiënter dan een reeks if-else uitspraken als u met meerdere aandoeningen te maken heeft. Het werkt als een d directe sprongtafel , waardoor het sneller en meer geoptimaliseerd is qua uitvoeringstijd.Case-gebaseerde logica:De schakel verklaring past uiteraard in scenario's waarin het programma beslissingen moet nemen op basis van specifieke waarden van een enkele variabele. Het is een intuïtieve en eenvoudige manier om casusgebaseerde logica te implementeren.

De schakel verklaring ondersteunt het gebruik van een standaardgeval dat dient als een catch-all optie voor waarden die niet overeenkomen met de opgegeven gevallen. Dit standaard geval omgaat met ongebruikelijke input of omstandigheden die niet uitdrukkelijk worden vermeld.

Nadelen van de switch-instructie:

Er zijn verschillende nadelen van de schakel verklaring in C. Enkele belangrijke nadelen van de switch-instructie zijn als volgt:

Beperkte uitdrukkingen:De uitdrukking die wordt gebruikt in de schakel verklaring moet resulteren in een integrale waarde (char, int, enum) of een compatibel gegevenstype. Meer kan het niet aan complexe of niet-constante uitdrukkingen , het beperken ervan flexibiliteit in sommige scenario's.Onvermogen om bereiken te vergelijken:in tegenstelling tot if-else uitspraken , de schakel verklaring kan waardenbereiken niet rechtstreeks verwerken. Elk geval in de switch-instructie vertegenwoordigt een specifieke constante waarde, waardoor het een uitdaging is om efficiënt met een reeks waarden om te gaan.Geen ondersteuning voor getallen met drijvende komma:De schakel verklaring accepteert alleen integrale typen (gehele getallen) en waarden uit opsommingen ; het accepteert geen getallen met drijvende komma. Het werkt niet niet-integrale gegevenstypen leuk vinden drijvende komma gehele getallen , wat in sommige omstandigheden problematisch kan zijn.Doorvalgedrag: Schakel verklaringen in hebben 'doorval' gedrag dat standaard inhoudt dat als een zaak geen a 'breek'-verklaring , executie zal 'doorvallen' naar het volgende casusblok. Als dit niet op de juiste manier wordt beheerd, kan dit leiden tot ongewenst gedrag.Dubbele code:Gebruik maken van een schakel verklaring kan onder bepaalde omstandigheden resulteren in dubbele code, vooral wanneer in veel gevallen dezelfde acties nodig zijn. Als dit niet goed wordt beheerd, kan dit leiden tot duplicatie van code.Geneste schakelaars kunnen complex worden:Bij het omgaan met genest uitspraken wisselen , kan de code complex en minder leesbaar worden. Het kan extra inspanning vergen om dergelijke geneste structuren te begrijpen en te onderhouden.