Hallo en welkom. In deze lezing wil ik het hebben over de schakelverklaring.
Het is een alternatief voor een
if-statement, maar wordt meestal alleen in specifieke situaties gebruikt.
Maar het heeft een leuke, coole syntaxis om wat herhaling in je if-statement te doen.
Dus de conditionele operator en de if than else-statements maken
het gemakkelijk om programma's te schrijven die tussen twee alternatieven kiezen.
Het is heel gemakkelijk om vragen te stellen en beslissingen te nemen.
Vaak moet een
programma echter een van de verschillende alternatieven kiezen.
En dit zou in
wezen de als anders als anders als anders als anders als.
Het is rommelig omdat je dit natuurlijk kunt implementeren met het if-statement als
je verschillende alternatieven hebt, maar
je zou honderd andere ifs kunnen hebben. Dus het is vervelend, het is vatbaar voor fouten, en het
is eigenlijk gewoon een pijn in de kont. Het is alsof je een heleboel standaardcode schrijft.
Dus het alternatief voor deze syntaxis en alles wat je in de
switch kunt doen, kun je in een if doen.
Maar het is schoner en makkelijker te doen en het is ook nog eens veel efficiënter.
Dus wanneer de waarde van een variabele met succes wordt vergeleken met verschillende waarden, gebruik
dan de switch-instructie.
En wat dit betekent als je een if-statement hebt en dan een else if, else if, else if,
else if, else if, else if, gebruik de switch-statement.
Als die Booleaanse uitdrukkingen een beetje ingewikkelder zijn.
U kunt geen switch-statement gebruiken. U kunt een
switch-statement alleen gebruiken als u vergelijkt met een waarde, zoals een constante.
Zo ingewikkeld kan de uitdrukking niet zijn.
Maar het is veel handiger en efficiënter om de switch-instructie te gebruiken, en de
meeste talen hebben deze constructie ook. En kijk, het is erg leuk. Het enige dat je
opvalt, is dat veel talen zullen bouwen op basis van c.
Als je eerder hebt geprogrammeerd,
zul je veel van deze constructies zien en
ermee bekend raken omdat ze oorspronkelijk uitkwamen in c of be, de taal ervoor.
Dus hier is de syntaxis van een switch-instructie. Je hebt het sleutelwoord switch.
En dan in de schakelaar heb je deze linker- en rechterhaakjes,
wat de uitdrukking is. Het ziet er dus net zo uit als
de if-instructie aan het begin, behalve in plaats van het if-sleutelwoord, je hebt het switch-sleutelwoord.
Je hebt dan de linker beugel.
De linker haakjes vereist. Die linkerbeugel begint het lichaam van de schakelaar.
En je ziet de eindigende rechter haak helemaal onderaan, die het lichaam van de schakelaar beëindigt.
Het andere dat hier belangrijk is, is het geval van deze zoekwoorden.
Case is eigenlijk hetzelfde als
de if-statement zelf. Switch gaat dus
eigenlijk naar een uitdrukking kijken, niet
of het noodzakelijkerwijs waar of onwaar is.
De schakelaar kan gewoon naar een variabele kijken of zoiets.
En dan gaat het die variabele evalueren in de case-statements.
Dus als waarde 1 gelijk is aan uitdrukking,
als waarde n gelijk is aan uitdrukking.
Maar je kunt dit zien alsof de
schakelaar zich op het hoogste niveau bevindt en dat de gevallen elk een if-statement
zijn, waarbij de waarden worden vergeleken met de expressies in de schakelaar.
Dus gevallen zijn ook sleutelwoord. Je merkt ook de dubbele punt na de zaak.
Dus je hebt zaak en dan heb je je waarde.
En daarbinnen kun je meerdere programma-instructies hebben.
En dan aan het einde heb je een break-trefwoord. Dat is een ander sleutelwoord. Er zijn hier
dus drie sleutelwoorden, eigenlijk vier. Er is het sleutelwoord switch, het sleutelwoord case, het sleutelwoord
break en dan de standaard onderaan.
Dit zijn dus de belangrijkste dingen om op te merken. We zullen een gedetailleerd voorbeeld
doornemen, maar u kunt verschillende gevallen hebben. En nogmaals, dit is gewoon doen als een als anders, als anders, als anders, anders als.
Dus als waarde één gelijk is aan expressie, voer dan de code uit.
Anders, als waarde twee gelijk is aan
expressie, evalueer dat dan. Anders, als waarde drie gelijk is aan expressie, evalueer dat dan.
Anders, als waarde n gelijk is aan expressie, voert u de code binnen dat blok uit.
En het blok voor de gevallen begint met de dubbele punt en eindigt met de pauze.
En als je die breuk daar niet hebt, zal
het door de andere gevallen vallen. Daar gaan we het nog eens over hebben.
En het laatste dat hier belangrijk is, is dit standaardzoekwoord. Dit is in wezen anders,
anders als, anders als, anders als en dan anders onderaan.
Dit wordt dus ingesteld als geen van de andere gevallen de expressie oplevert.
Dus laten we het hebben over enkele van die details die ik noemde.
De uitdrukking tussen haakjes is succesvol vergeleken met de waarden.
Dus nogmaals,
als we teruggaan naar de syntaxis, wordt expressie vergeleken met alle waarden.
En als het gelijk is aan een van de waarden, voer je de code binnen die waarde uit.
Cases moeten eenvoudige constanten of constante uitdrukkingen zijn, uitdrukkingen
die een constante opleveren.
Dus je zou x plus y kunnen inschakelen,
want als x 5 is, zou dat gewoon 10 inschakelen en de waarden vergelijken met 10.
Maar meestal schakel je een variabele in die gelijk is aan een soort getal.
Als een case wordt gevonden waarvan de waarde gelijk is aan de waarde van de expressie,
dan worden de instructies die op de case volgen uitgevoerd.
Als er meer dan één stelling is opgenomen, hoeven deze niet tussen accolades te worden gesloten.
Dus dat wil alleen maar zeggen
dat wanneer er meer dan één verklaring is opgenomen,
er geen accolades nodig zijn voor de casusverklaringen.
Onthoud dat voor de if-statement, we altijd die accolades zouden
moeten hebben, dat is niet het geval. Je kunt ze gewoon de ene regel na de andere plaatsen, de sleutel is de pauze daar.
De break-instructie geeft het einde van het specifieke geval aan en
zorgt ervoor dat de uitvoering van de instructie wordt beëindigd,
het springt eruit.
Als je de pauze daar niet hebt, zal het de volgende zaak niet doorgaan.
Dus u wilt het einde van de break-statement van elke case opnemen. Als je pauzes niet opneemt, betekent dit meestal
dat er een fout is of zoiets.
De enige reden waarom u een pauze wilt opnemen, is als u meerdere voorwaarden
had om code uit te voeren. Dus als je meerdere gevallen had,
in feite zeggend of de uitdrukking
dit geval, dit geval of dat geval was, doe
dan hetzelfde, dan
zou je de pauzes wegnemen.
Wees dus voorzichtig met de pauzes, want de pauzes kunnen problemen
veroorzaken, ongeacht of bepaalde blokken in het volgende geval worden uitgevoerd of niet.
Het speciale optionele geval dat de standaard wordt genoemd, wordt uitgevoerd als de waarde
van de uitdrukking met geen van de gevallen overeenkomt. Het is hetzelfde als een val, anders gebeurt het
als geen van de gevallen waar is.
Dus hier is een mooi voorbeeld waarbij we een schakelaar maken om een opsomming te evalueren.
In dit geval hebben we een opsommingstype met de naam weekdag,
dat alleen wordt gespecificeerd door alle weekdagen.
En dan hebben we een variabele van het type enum weekdag gemaakt en die hebben we op maandag gezet en
dan gaan we vandaag aan.
Dus afhankelijk van de waarde van vandaag, de variabele,
wordt een van de case-statements uitgevoerd.
Als vandaag gelijk is aan zondag, wordt het vandaag als zondag
afgedrukt en dan eruit springen.
Als vandaag gelijk is aan maandag, wordt het vandaag afgedrukt als maandag en spring je eruit.
Als het niet gelijk is aan
een van hen, gaat het naar het standaardgeval. Laten we dit voorbeeld dus in codeblokken doornemen.
Hier hebben we onze voorbeeldcode. En dat zul je zien, want vandaag is
gelijk aan maandag, het geval dat
maandag wordt geëvalueerd en je zult zien dat de uitvoer van vandaag maandag is.
Dus laten we doorgaan en deze code bouwen en uitvoeren. En dat is wat we gaan zien, het
is vandaag maandag.
Want wat hier gebeurt, is dat vandaag de maandag wordt. U plaatst dit de uitdrukking
die u de variabele vandaag wilt evalueren en evalueert deze vervolgens.
De belangrijkste dingen om hier te onthouden, zijn dat
je een haakje hebt om de switch-instructie op regel 16 te beginnen in een
eindhaakje om de naam van de switch op regel 29 te eindigen.
U kunt meerdere regels binnen elke case-instructie hebben zonder haakjes te gebruiken.
Laten we nu eens kijken wat er gebeurt
als we de break-verklaring na maandag verwijderen.
Want onthoud, break springt meteen uit de koffer. Maar als we het
verwijderen, wat er gaat gebeuren, is dat
het doorgaat naar dinsdag en je zult zien dat beide printfs
worden uitgevoerd voor maandag van vandaag en vandaag is het dinsdag.
Dus als we het programma nu uitvoeren, zien
we dat het vandaag maandag is, en dat het vandaag dinsdag is.
Dat is het belang van de break-statement.
De pauze springt eruit.
Dit kan dus handig zijn als u dezelfde uitvoer wilt voor maandag en dinsdag.
Dus soms zie je bijvoorbeeld case-statements
zoals deze, case Tuesday omdat je dezelfde output wilt en het
maakt niet uit waar de variabele gelijk aan is.
Dus je kunt dat soort dingen zien, maar als je afzonderlijke case-statements
hebt die verschillende uitvoeringen hebben, moet je die pauze daar toevoegen.
We kijken dus alleen naar zondag, maandag en dinsdag.
Wat gebeurt er als we de waarde van vandaag gelijk stellen aan
zondag, omdat er geen gevallen zijn die daarmee overeenkomen.
Wel, wat er gaat gebeuren is dat het door de standaard gaat en het gaat afdrukken wat dan ook.
Dus laten we proberen dit opnieuw uit te voeren.
En we zien dat het vandaag zondag is.
Sorry, stel het in op de verkeerde variabele. Ik wil het instellen op,
laten we zeggen, woensdag. We hadden een zaak voor zondag.
Dus nu zullen we zien dat het werkelijk wat dan ook afdrukt, omdat het
met geen van de gevallen overeenkwam.
Dus alles wat je hoeft te doen om over te schakelen, is echt de syntaxis te onthouden.
De uitdrukking staat tussen haakjes, dat is wat je gaat evalueren.
De gevallen moeten overeenkomen met de uitdrukking. Dus meestal doe je variabelen, daarom
moeten het constanten of expressies zijn die evalueren naar een specifieke constante waarde.
En dan heb je cases voor elk ding en dan een standaard alle case, en vergeet de pauzes niet.
Laten we teruggaan en nog wat meer praten en nog een voorbeeld van
de switchconstructie met cases.
In dit volgende voorbeeld is het een beetje anders.
Wat we hier doen, is dat we gegevens van de gebruiker krijgen en die vervolgens inschakelen.
Dus in dit voorbeeld in onze hoofdfunctie, begint het met het maken
van een paar floats en vervolgens maakt het een tekenoperator en vraagt het de gebruiker om
een waarde, een operator en een waarde twee in te voeren.
En het gebruikt formaatspecificaties om onderscheid te maken, en ze hebben allemaal een adres van ampersands.
Afhankelijk van het teken dat u invoert voor de operator, of het nu plus min of ster is,
is dat wat u in uw schakelkast wilt opnemen.
Dus als de gebruiker een plus heeft
ingevoerd, zoals je in de volgende kolom hier ziet, de schakelaarconstructie, is het een inschakelende operator.
Het gaat de waarde van de operator, de waarde van de variabele operator, vergelijken
met elk van deze case-statements. En je zult merken dat deze
case-statements enkele aanhalingstekens om zich heen hebben, omdat we karakters vergelijken.
U kunt dus getallen,
variabelen vergelijken met waarden van specifieke constanten of tekens met specifieke constanten.
En dan drukken we in elke zaakverklaring een specifiek formaat af.
Waarde één plus waarde twee, waarde één minus waarde twee.
We zijn eigenlijk bezig met het uitvoeren van berekeningen in onze print.
En dan zie je weer die belangrijke breekverklaringen die eruit
springen, en ze zijn nodig als je niet door een van de andere gevallen wilt vallen.
Je merkt ook dat in die laatste case-statement waar de slash de scheidingslijn heeft, we
een if-statement hebben.
We hebben geen haakjes rond de zaak
omdat we in elk geval meerdere uitspraken kunnen hebben zonder haakjes.
Dus het laatste geval dat we zeggen als waarde twee gelijk is aan 0, doen we een
kleine controle om er zeker van te zijn dat we niet delen door 0.
En als we niet delen door 0, dan gaan we onze deling uitvoeren.
En dan, helemaal aan het einde van die zaak, hebben we nog een pauze.
Ons standaardgeval zegt dat u een operator hebt ingevoerd waarvan we niet weten hoe deze moet worden afgehandeld.
Maar de switch-statement is zeer efficiënt.
Het is erg snel om te schrijven wanneer u
veel verschillende waarden met een specifieke variabele vergelijkt en vervolgens verschillende dingen wilt doen.
Het laatste dat ik wilde noemen, was de 'go to'-verklaring met betrekking tot besluitvorming.
Het is geen directe beslissingsverklaring,
het is meer een sprong naar een andere regel code, met behulp van een
label, maar het is beschikbaar in c, en daarom wilde ik het noemen.
Het go to-statement bestaat uit twee delen, het label en het go to-trefwoord.
Nu, voor degenen onder u die eerder in
Fortran of een andere basistalen hebben geprogrammeerd, u zult dit waarschijnlijk herkennen en u hebt
het waarschijnlijk nogal wat gebruikt.
Als we nu naar c komen, is het niet nodig om
het echt te gebruiken. Er zijn een paar gevallen waarin
ik zag dat het behoorlijk nuttig was, wat ik in een oogwenk zal uitleggen, maar de go to is om naar
een code te springen en je zou naar elke regel code kunnen gaan.
Een van de redenen waarom mensen het niet graag gebruiken, omdat het erg moeilijk te volgen is.
Als je een programma onderhoudt en als het sequentieel is, ga je
regel voor regel, if-statements in de while-loops.
Het is al erg genoeg als je de if-statements in de while-lussen hebt.
Maar als je nu iets hebt waar je in principe op regel 27 van je
broncode zit en je gaat naar regel 800 zonder andere reden dan alleen het zoekwoord, dan sla je ineens
een hoop code over, en het is erg moeilijk te onderhouden en te volgen.
Dus de twee delen om naar toe te gaan en de labelnaam. De naam van het
label volgt dezelfde conventie voor het benoemen van een variabele, alfanumerieke tekens, u kunt
niet beginnen met cijfers, u kunt beginnen met onderstrepingstekens.
je kunt beginnen met onderstrepingstekens.
Kortom, je gebruikt gewoon het zoekwoord ga naar en je gaat naar een
identifier, deel twee. Deel twee is ergens een label.
Dus om daadwerkelijk naar die regel code te springen, moet je die regel code een label geven.
Er moet een verklaring zijn die deel twee zegt.
Nu zal ik je hier een voorbeeld van laten zien, maar je zou dit echt
nooit moeten gebruiken vanwege de problemen die gepaard gaan met onderhoud.
Ik wilde het echter vermelden als je eerder hebt geprogrammeerd en gewend bent om het te gebruiken.
In c hoef je het niet zo vaak te gebruiken.
Er is één use-case die ik zag die nuttig zou kunnen zijn.
Ik werkte onlangs met een collega-programmeur en
hij had een aantal geneste loops
of geneste if-statements.
Maar de lussen is waarschijnlijk het betere voorbeeld. Loops, onthoud, herhalende code. Hij had veel geneste lussen.
En bij de binnenste geneste lus, zoals de vijfde, wilde
hij uit alle lussen springen omdat hij een bepaalde aandoening had.
En dus ging hij altijd naar om uit al die lussen te springen.
Nu is de andere manier om uit lussen te springen het gebruik
van het remsleutelwoord, maar de rem springt alleen uit de meest binnenste.
Dus er was echt geen effectieve manier zonder dat hij een aantal
vlaggen instelde en een aantal if-statements had om elke afzonderlijke lus te verlaten,
waar hij altijd naar toe ging. En dat was een geval waarvan ik dacht dat
het best handig was omdat het de hoeveelheid code die je moest schrijven, verminderde en het vrij duidelijk was over wat er gebeurde.
Je sprong gewoon uit alle geneste lussen omdat je aan
een bepaalde voorwaarde voldeed.
En dat is één geval. Maar voor het grootste deel hoef je niet echt naar toe te
gaan en om de redenen die ik noemde is het erg problematisch, het is moeilijk om de code te volgen als je alle kanten op springt.
Maar de go to is net zoals je het gebruikt, net zoals je het in andere talen gebruikt.
U hebt een zoekwoord met de labelnaam.
En wat er in uw code zal gebeuren, is dat u naar die regel code met het label springt.
Je kunt dus allerlei soorten code overslaan.
Dus in dit voorbeeld hier hebben we een label met de naam top, en het
heeft een dubbele punt. Zo weet je dat het een label is.
En top heeft enkele uitspraken. En helemaal onderaan
heb je een if-statement. En je zegt als de char gelijk is aan y, ga naar de top.
Dus nogmaals, je ziet hoe je gewoon overal in je code kunt springen en dat maakt het erg moeilijk om te volgen.
Gebruik het dus eigenlijk niet, tenzij je heel veel geneste lussen hebt en je
uit alle lussen wilt springen. Dank u.