Hallo en welkom. In deze lezing wil ik het hebben over geneste loops en loop control.
Geneste loops, loops binnen loops, loop control heeft te maken met de
break en de continue statements.
Dus geneste lussen.
Er zijn momenten waarop u een lus in een andere lus wilt plaatsen.
Het is volkomen logisch.
U wilt bijvoorbeeld
het aantal bewoners van elk huis in een straat tellen.
Dus wat je zou doen, is dat je een buitenste lus zou hebben waar je van huis naar huis stapt.
En dan zou je voor elk huis waar je binnen bent het aantal bewoners tellen.
Dus ik hoop dat je kunt visualiseren of begrijpen hoe dat een geneste lus zou kunnen zijn.
Nogmaals, de buitenste lus om door alle huizen te gaan.
En dan voor elke iteratie van de buitenste lus van elk huis dat je tegenkomt, zou je het
huis binnengaan en een lus hebben om alle mensen te tellen.
Dus dat is een kleine use-case als je een geneste
lus in c wilt gebruiken.
Hier is een voorbeeld. Het ziet eruit alsof je denkt
dat het eruit ziet als een lus in een lus, echt niet te ingewikkeld.
In dit voorbeeld gebruiken we for-lussen voor.
Lussen zijn leuk omdat we de luscontrolevariabele kunnen
initialiseren, onze conditiecontrole en onze wijzigingsluscontrolevariabele allemaal op één regel kunnen hebben.
Dus deze buitenste lus en noem het de buitenste binnenste lus.
De buitenste lus is precies wat het impliceert. Het is de lus aan de buitenkant.
En je kunt heel veel verschillende nestlagen hebben. Je zou veel binnenlussen
kunnen hebben.
In dit geval gaan we door en
het is een tegengestuurde lus, we beginnen bij één en we gaan helemaal tellen.
We weten niet welke telling hier is, het maakt niet uit.
In de body van de for-lus zeggen we dat de som gelijk is aan 0. We initialiseren de som voor de binnenste lus.
En dan binnen de binnenste lus, zien we een andere for-lus voor en j is gelijk aan 1, j
is kleiner dan gelijk aan I en plus plus j. We zeggen dan som plus is gelijk aan j.
We berekenen de som van de gehele getallen van 1 tot I.
Dus wat dit eigenlijk doet, is dat je een nummer 5 invoert.
En voor de eerste iteratie van de lus tel
je 1 2 3 4 en 5 op.
Voor de volgende iteratie van de
lus tel je 2 3 4 5 op.
Voor de derde iteratie van de lus tel je 3 4 5 op, enzovoort.
Dus innerlijke lussen zijn nodig, vooral alleen op basis van de use case, gewoon een
lus in een lus perfect.
Je gaat het nogal eens zien.
Schaam je er niet voor. Afhankelijk van wat je moet doen en welk probleem je probeert op te
lossen, wordt het vaak nogal wat gebruikt.
En tot dat punt is het niet altijd een for-lus in een for-lus, je kunt
een while-lus in een for-lus hebben. Je zou een doe while-lus in een for-lus kunnen hebben,
het maakt niet uit.
Dus in dit
voorbeeld, exact hetzelfde voorbeeld, behalve nu in de body van de for-lus,
hebben we een geneste lus, een binnenste lus die wordt genoemd met het while-sleutelwoord.
Dus we zijn nog steeds enkele gehele getallen aan het berekenen van 1 tot I.
We hebben een uh-initialisatie buiten de while-lus.
We hebben een voorwaarde in de while-controle en
we hebben onze sommen in de body van de while-lus waar
we zijn gewijzigd, dat is de regelvariabele van de lus die we wijzigen.
Dus som plus is gelijk aan en dan wijzigen we de regelvariabele van de lus met plus plus j.
Dus als we plus plus j niet zouden wijzigen, zouden we een oneindige lus hebben voor de while-lus.
Maar het doet dezelfde uitvoer, het gebruikt gewoon een while-lus als een geneste lus in plaats van de for-lus.
Dus het nesten is niet echt anders dan wanneer je iets nest.
U geneste if-statements, if-statements binnen if-statements, geneste
loop-statements lussen binnen lussen.
Laten we het hebben over de instructie
continue om af te stappen van het concept van geneste lussen.
Tot nu toe, toen we het over lussen hadden,
hebben we de lus altijd een aantal keren uitgevoerd op basis van de
exit-voorwaarde, de Booleaanse expressie die evalueert naar false.
Er zijn echter momenten waarop u een lus specifiek voortijdig wilt beëindigen of u
wilt doorgaan met de volgende iteratie van
de lus zonder iets te doen.
In het laatste geval doorgaan zonder iets te
doen, in wezen overslaan, kunt
u hiervoor de instructie continue gebruiken.
Dus de instructie continue in de body van een lus doet het volgende.
En allereerst, als je dit wilt initiëren, hoef je alleen maar het sleutelwoord continue gevolgd door
een puntkomma in de hoofdtekst van de lus te plaatsen.
Maar wat het gaat doen, is dat het die
iteratie in feite overslaat. Dus het vervolg alles onder het
vervolg wordt niet uitgevoerd als het zich in de hoofdtekst van de lus bevindt.
Dus ga zo vaak door dat we bovenaan de lus willen staan op
basis van een voorwaarde, het is meestal verpakt in een if-statement.
Als dit in een speciale situatie gebeurt, wil ik niets van
de code in de hoofdtekst van de lus uitvoeren,
sla deze ene iteratie over en controleer de volgende keer.
En nogmaals, het is een beetje verwarrend omdat je een iteratie overslaat en rondspringt, maar het is geldig
en het is een manier om meerdere controles uit te voeren.
Dus ook al heb je je loop-exit-conditie in je Booleaanse expressie, je
kunt nog een controle uitvoeren.
En die controle springt niet uit de lus, maar slaat
een iteratie over.
Dus het wordt opnieuw gebruikt voor het geval je iteratie wilt overslaan. Het voordeel hiervan is dat
je continue kunt gebruiken en het elimineert veel nesting.
Het elimineert ook veel extra if-statements in je blok met lussen.
Het kan dus de leesbaarheid verbeteren als
de uitspraken erg lang zijn of als je diep genest bent.
Dus als je merkt dat je veel aan het nestelen bent.
misschien wil je zeggen huh misschien kan ik in plaats daarvan een doorgaan gebruiken.
Of als je merkt dat je veel if-statements
hebt die bepaalde dingen doen binnen de body van de lus, wil je misschien doorgaan.
Gebruik de continuering niet als het ingewikkelder is dan de code te vereenvoudigen.
Gebruik niet doorgaan als u niet weet wat u doet.
Hier is een voorbeeld van de continue.
In dit voorbeeld maken we een nieuwe opsomming van het type
dag en zeggen we dat de geldige waarden Maandag Dinsdag Woensdag Donderdag Vrijdag Zaterdag Zondag zijn.
En dan hebben we een for-lus waarbij we onze opsomming initialiseren op maandag,
en we zeggen dat zolang de dag
kleiner is dan gelijk aan zondag, dat een voorwaarde is om
af te sluiten en dan zeggen we plus plus dag.
Je kunt jezelf de vraag stellen hoe we een opsomming ophogen?
Onthoud dat een opsomming onder de motorkap een geheel getal is.
Dus je kunt plus plus dag op een opsomming zeggen en dat verhoogt het gewoon naar de volgende.
Onthoud, maandag is gelijk aan 0, dinsdag is gelijk aan 1, woensdag is
gelijk aan 2, het is allemaal de volgorde van de lijst.
Dus prima om opsommingen te verhogen.
In deze for-loop als het woensdag is, willen
we overslaan. We willen niets doen. We willen niet printen.
Dus we zeggen doorgaan. Als de dag gelijk is aan
woensdag, ga dan verder. Het gaat de afdrukregel overslaan. Het gaat terug naar de
bovenkant van de lus en voert de volgende iteratie uit.
En dus wordt het dan donderdag.
Het wordt niet gelijk aan woensdag, dus het gaat niet overslaan.
Het gaat regelrecht naar beneden en uitprinten dat het geen woensdag is.
Dit is dus een veelvoorkomende use-case, een veelvoorkomend voorbeeld van het gebruik van continue, zeer gebruiksvriendelijke syntaxis, slechts
een eenvoudig trefwoord gevolgd door de puntkomma.
Het andere geval waarin je misschien iets raars in de lus wilt doen,
is als je vroeg wilt stoppen.
Dus normaal gesproken, nadat de body de lus is
ingevoerd, zal een programma alle instructies in de body van de lus en
voor elke iteratie uitvoeren en dan zal het controleren en eruit springen.
En we weten hoe de continue werkt, dat is een beetje anders overslaan.
Er is nog een instructie die de uitvoering van alle instructies in de lus kan veranderen, dit
wordt de break genoemd.
En dit zou enigszins bekend moeten zijn, omdat we het break-sleutelwoord gebruiken toen we het hadden
over de switch-instructie.
Bedenk dat als we onze zaken hadden, we op die manier uit de zaken zouden ontsnappen.
Welnu, u kunt ook het break-trefwoord in een lus gebruiken.
En wat dit zal doen, is dat het gewoon uit de lus springt.
Dus de break-instructie zorgt ervoor dat het programma onmiddellijk de lus verlaat, het wordt uitgevoerd.
Verklaringen in de lus worden overgeslagen en de uitvoering van de lus wordt beëindigd.
Dus je springt gewoon uit de lus.
Je executeert vroeg. Als de break-instructie zich in geneste lussen bevindt, heeft dit alleen
invloed op de binnenste lus die deze bevat. Je springt alleen uit de lus waar je in zit.
En hiervoor gebruik je het trefwoord break gevolgd door een puntkomma.
Pauze wordt vaak gebruikt om een lus te verlaten wanneer er 2 verschillende redenen zijn om te vertrekken.
Dus eerder vermeldde ik dat je misschien een andere reden hebt waarom je een iteratie
wilt overslaan, maar als er 2 redenen zijn, 2 omstandigheden waarin je uit een lus wilt springen, kun
je een pauze gebruiken.
Als je maar één
voorwaarde hebt, dan is het alleen de voorwaarde, binnen de lus zelf, tussen de
haakjes van de while of voor de tweede puntkomma in de for-lus.
Break wordt ook gebruikt in switch-statements, zoals ik al zei.
Dus daar wilde ik je even aan herinneren. Breng ze niet in de war.
Ze doen echter in wezen dezelfde dingen. Ze springen uit de code.
Het verbreken van een switch-instructie springt volledig
uit die switch-instructie, het verbreken van een lus springt uit die lus.
Nou, hier is een voorbeeld. We hebben een while-loop.
We printen enkele gehele getallen uit.
We lezen enkele gehele getallen in. We hebben een geneste while-lus.
Binnen de geneste while-lus controleren we wat
er is ingevoerd. En als het groter is dan
100, willen we uit die binnenste lus springen. Dus dat doen we.
Dan in de buitenste lus, moeten we nog een controle doen. Als het groter is dan 100, breken
we uit die buitenste lus.
Als je de tweede pauze niet had, zou je nooit uit de tweede buitenste lus springen.
Dus in dit geval doet dit me denken aan een plek waar je een go to zou kunnen gebruiken.
Stel je voor dat je 5 nesten had, 5 lagen nesting, while-lus
in een while-lus binnen een while-lus binnenin while-lus binnenin while-lus.
Als je alleen de break zou gebruiken om uit lussen
te springen, zou je al deze if-statements in elke lus hebben om eruit te springen.
In plaats van al die if-statements te doen,
zou je eens kunnen proberen. De go to zou in één enkele opdracht uit alle lusstatuslussen springen.
Dus dat is een use-case voor een go to. Maar in dit geval demonstreren we
alleen pauzes en zorgen we ervoor dat je begrijpt dat je
net uit die lus breekt waar je in zit.
En in dit geval breken we uit 2 lussen.
Dit zijn dus de 2 voorbeelden, de 2 trefwoorden waarbij je in wezen de code niet kunt
herhalen van wat je ervan verwacht.
Dus als je ooit een pauze ziet of doorgaat in de lus, zorg er dan voor
dat je begrijpt wat er aan de hand is, want
het kan zijn dat je bepaalde code niet uitvoert waarvan je denkt dat deze zal worden uitgevoerd.
Nogmaals, meestal verpakt in een if-conditie. Zo kan je er
dus tegenaan kijken, maar je wilt ook goed commentaar geven als je pauze of vervolg gebruikt.
Ik hoop dat dit helpt. In de volgende lezing gaan
we een uitdaging doen waarbij we deze loops kunnen
gebruiken en het zal je demonstreren en je helpen alles te leren over while for loops en
break and continue. Dank u.