Hallo en welkom. In deze lezing wil ik het hebben over de while en while loops.
We hebben het gehad over de for-lus, waarmee je in wezen code kunt herhalen.
Er zijn andere constructies in c die while en do while worden genoemd en die hetzelfde doen
met alleen een andere syntaxis.
Dus de while-lus, de while-lus is een mechanisme voor het herhalen van een
reeks instructies en zorgt ervoor dat de uitvoering kan doorgaan zolang een opgegeven logische expressie als waar wordt geëvalueerd.
Dus meer van hetzelfde hier. Net zoals if-statements bepaalde code zullen uitvoeren,
terwijl statements bepaalde code een aantal keren zullen uitvoeren op basis van een Booleaanse evaluatie.
Alles wat je in de for-lus kunt doen, kun je in de while-lus
doen, het is gewoon een andere syntaxis.
Dus hoe de while-loops eruit zien, is zoiets als dit.
Op een zeer hoog niveau, als we naar pseudocode kijken,
terwijl deze voorwaarde waar is, blijf dit doen.
Dus om het te relateren aan een meer werelds wereldvoorbeeld.
Kortom, terwijl je honger hebt, eet sandwiches, zoiets.
Dus je gaat de code herhalen. Je blijft veel boterhammen eten terwijl je honger hebt.
De algemene syntaxis voor de while-lus is als volgt.
En dit toont u de syntaxis voor één uitspraak
in de hoofdtekst, dus u hoeft geen haakjes of accolades op te geven.
Ik heb de neiging om de termen accolades en
haakjes in dezelfde terminologie te gebruiken.
Dus hier is hoe de syntaxis eruitziet als je één statement hebt versus meerdere statements.
Meerdere uitspraken, je moet die haakjes hebben, een enkele
uitspraak heb je niet, ze zijn optioneel. Je kunt ze niet hebben of je hoeft ze niet te hebben.
De expressie staat tussen haakjes, net als de
for-lus en de if-statement. De uitdrukking hier verschilt van
de for-lus in die zin dat het een enkele exit-voorwaarde is.
Het is gewoon de uitdrukking. U initialiseert de regelvariabele lus niet.
U wijzigt de regelvariabele lus tussen de haakjes niet.
Het is alleen de uitdrukking, alleen de exit-voorwaarde.
De voorwaarde voor voortzetting van de while-lus wordt aan het begin getest.
Dit is dus de top van de lus.
Dit betekent dus dat het een pretest-lus is. En wat dat betekent is dat
het 0 keer kan worden uitgevoerd of dat het meerdere keren in het lichaam kan worden uitgevoerd.
En nogmaals, dit zal relevant zijn omdat de do while-lus iets anders doet.
Als de expressie false begint, wordt geen van de
loop-instructies in de body uitgevoerd.
Dus daarom staat het op de bovenste test.
Dus als je de eerste vraag nee beantwoordt, ik heb geen
honger, dan ga je nooit boterhammen eten. Je gaat direct naar de koffie
of de volgende regel code. Je gaat niet het lichaam van de lus in.
Als de lusvoorwaarde als waar begint, moet
de lustekst een mechanisme bevatten om dit te veranderen
als de lus moet eindigen. Anders krijg je een oneindige lus.
Dus met de for-lus waarbij je de regelvariabele lus in een enkele instructie wijzigt, is het hetzelfde in
de while-lus, behalve dat je het in de body moet doen.
De while-lus gaat de regelvariabele
van de lus ergens initialiseren, en dan wordt hij
in de hoofdtekst van de code gewijzigd.
Dus zoals ik al zei, de while-lus kan alles doen wat een for-lus doet, het is gewoon een andere syntaxis.
En nogmaals, de for-lus is meer is korter. Je kunt alles op één regel
doen, terwijl je bij de while-lus die 3 dingen op aparte regels moet doen.
Dus in dit
voorbeeld is int count gelijk aan 0. Dit is de regelvariabele van de lus. Dit valt buiten de while-lus-instructie.
Als u een for-statement zou gebruiken, zou dit binnen de for-lus gaan zoals vóór de eerste puntkomma.
Dat is waar de luscontrolevariabele wordt geïnitialiseerd.
Dan heb je het while-sleutelwoord en tussen haakjes de Booleaanse uitdrukking.
Dit zou gelijk zijn aan de for-lus, de tweede
instructie vlak voor de tweede puntkomma.
Dus dit is wat u controleert op waar of onwaar. En als het waar of niet waar is, ga je naar de hoofdtekst van de lus.
Als het aantal kleiner is dan 5, dan gaat u het aantal afdrukken.
De volgende regel code daarna is erg belangrijk,
het plus plus-aantal omdat dat de regelvariabele van de lus wijzigt.
Je moet dit plus plus tellen doen, anders verlaat je de lus nooit omdat de voorwaarde bovenaan
zegt of de telling kleiner is dan gelijk aan 5. Als de telling altijd gelijk is aan 1, heb
je een oneindige lus.
Dus dat plus plus tellen heel, heel erg belangrijk.
Plus plus count Remember is een incrementele operator.
Het is gewoon zeggen dat tel gelijk is aan tel plus 1.
Deze lus gaat 5 keer lopen.
Het gaat lopen met tellen gelijk aan 1,
tellen gelijk aan 2, tellen gelijk aan 3, tellen gelijk aan 4 en tellen gelijk aan 5.
Als het aantal eenmaal gelijk is aan 6, springt het uit de lus
en verlaat het geen uitspraken meer in de body.
Nogmaals, je zou moeten denken in termen van de for-lus.
Het is gewoon de regelvariabele van de lus en de wijziging van de regelvariabele
van de lus is niet in de verklaring van de eigenlijke lus.
Het staat niet allemaal in één regel, zoals in de for-lus.
Hier is nog een voorbeeld waarbij de logica wordt bestuurd om de lus te beëindigen.
Dus in dat eerste voorbeeld hier dat ik liet zien, is dit een tegenregellus.
Het wordt altijd hetzelfde aantal keren uitgevoerd, namelijk 5.
In het volgende voorbeeld is dit een voorbeeld waarbij de lus 100 keer
of 0 keer kan worden uitgevoerd.
De voorwaarde die we hier evalueren in onze while-toets waarbij num niet gelijk is aan
min 1 is allemaal afhankelijk van wat de gebruiker invoert, omdat
num is wat de gebruiker invoert.
Dus deze lus kan 0 keer worden uitgevoerd, hij kan 100 keer worden uitgevoerd.
Het hangt allemaal af van de invoer van het toetsenbord.
En dit wordt een schildwacht-regellus genoemd. Het is niet tegengestuurd.
Het is gebaseerd op logica en variabelen die kunnen veranderen.
Dus terwijl num niet gelijk is aan min 1 en dan wordt num de
waarde opgeslagen die we op het toetsenbord invoeren.
Als de gebruiker nooit een negatieve 1 op het toetsenbord invoert, zal deze lus nooit eindigen.
Dus hetzelfde type syntaxis hier met onze while.
Onze regelvariabele voor de lus is hier num. We initialiseren de 0 bovenaan, en dan
lezen we het in om het te wijzigen om te zien of we de lus gaan betreden op basis
van wat de gebruiker op het toetsenbord heeft ingevoerd.
Vervolgens controleren we tussen haakjes voor het zoekwoord while het om
te zien of het een negatief 1 is.
En dan in de body van de while-lus met de haakjes, hoeven de
haakjes er niet te zijn omdat er een enkele instructie is, maar ik zet ze er graag in.
Dan lezen we ook de volgende invoer en slaan we op in num.
Als de gebruiker een negatieve 1 invoert voor die volgende invoer, springt deze uit de lus.
Als ze dat niet doen, zal het doorgaan met uitvoeren en hen vragen om informatie in te voeren.
Een do while-lus verschilt een beetje van de
for-lus in de while-lus, omdat het wordt beschouwd als een post-test-lus.
Dus in de while-lus wordt de body uitgevoerd terwijl de voorwaarde waar is.
In de do while-lus waarbij de body voor de eerste keer onvoorwaardelijk wordt uitgevoerd, betekent
de do while-lus omdat de test onderaan staat
dat je de lus altijd minstens één keer gaat uitvoeren.
Je gaat het lichaam altijd minstens één keer
uitvoeren, het kunnen meer zijn, maar het is altijd één, het is nooit 0.
Omdat de voorwaarde om de uitgang te testen onderaan staat.
Dit wordt een post-test lus genoemd. Het wordt ook wel een exit-gecontroleerde lus genoemd.
Dus je zou de do a while-lus gebruiken als je wilt dat de lus minstens
één keer wordt ingevoerd.
Meestal hoef je geen do while-lus te gebruiken, omdat je
nog steeds hetzelfde in een for-lus kunt doen als je dat zou willen, je
zou de code gewoon buiten de lus plaatsen.
Dus de do while-lus is niet echt nodig, maar er zijn gevallen waarin je hem misschien wilt gebruiken.
Na de eerste uitvoering wordt de
body alleen uitgevoerd als de voorwaarde waar is. Dus na de eerste iteratie van de lus,
gaat het net als normale lussen werken. Het zal eruit springen als de voorwaarde onwaar is.
Dus hier is hoe het eruit ziet. De do staat bovenaan en
vervolgens staat het testen voor de conditie onderaan met het while-sleutelwoord.
Dus doe is een
nieuw trefwoord en dan heb je ofwel haakjes of niet-haakjes, afhankelijk van of
je al dan niet meerdere uitspraken in de hoofdtekst hebt.
Als je maar één statement in de body hebt, heb je geen haakje. Je hoeft alleen maar bovenaan te doen
en dan heb je de tijd onderaan de lus.
En binnen de tijd, de haakjes, heb je de Booleaanse evaluatie die de voorwaarde
is die je aanvinkt. Maar nogmaals, omdat die
voorwaarde onderaan staat, ben je er altijd zeker van dat je de instructie minstens één keer uitvoert.
En dus is het voorbeeld aan de linkerkant één statement, het voorbeeld aan
de rechterkant is meerdere statements. Dus je hebt de haakjes, de accolades.
En nogmaals, in dit tweede voorbeeld zeg je dat je misschien iets als een wachtwoordvraag hebt, lees de
gebruikersinvoer en terwijl de invoer niet gelijk is aan wachtwoord.
Maar u zult altijd minstens één keer om dat wachtwoord vragen.
Dus een ander voorbeeld van een while-lus.
Het eerste topvoorbeeld hier is een voorbeeld van hoe
de lus één of
meerdere keren kan worden uitgevoerd, maar nooit 0.
Het hangt allemaal af van wat de gebruiker invoert. Het wordt altijd minstens één keer uitgevoerd, maar dit
is invoer van het toetsenbord lezen. We zien de scanf-functie.
En zolang de gebruiker geen 20 invoert, zullen
ze deze lus uitvoeren.
Een while-lus kan ook een tegenregellus zijn, wat betekent dat hij een bepaald aantal keren wordt uitgevoerd.
In dit geval wordt het in dit voorbeeld 4 keer uitgevoerd.
We hebben int getal gelijk aan 4. En dan hebben we do bovenaan, en
dan hebben
we de haakjes omdat we meerdere uitspraken in het lichaam hebben.
En we verhogen die regelvariabele van de lus in het lichaam, getal plus plus.
En dan staat de voorwaarde voor controle nog steeds onderaan. Je gaat dit dus 4 keer uitvoeren.
En u zult zien dat het while-trefwoord niet op dezelfde regel hoeft te staan als de juiste accolade.
Meestal is dat wel zo, maar het hoeft niet zo te zijn.
En het while-trefwoord onderaan eindigt ook op een puntkomma, dat zou je ook moeten opmerken.
Dus we hebben alles geleerd over deze lussen; de for-lus, de while en do while.
Welke lussen moet je gebruiken?
Welnu, het eerste dat u moet beslissen over welke lus u wilt gebruiken, is eerst: wilt u
dat het een pre-test of post-test is? Wil je dat het minstens één keer wordt
uitgevoerd of niet minstens één keer? Als je wilt dat het minstens
één keer wordt uitgevoerd, gebruik je de do while. Als dat geen voorwaarde is,
kunt u de for of the while of de do while gebruiken.
Dus als u beslist welke lus u wilt gebruiken, zal het voor het
grootste deel altijd een pre-testlus zijn. Je moet wegblijven van de do while-lus.
In de meeste gevallen is het gewoon een betere optie. Het is veel gemakkelijker te lezen.
Het is veel beter om te kijken voordat je daadwerkelijk een lus maakt.
Begin gewoon niet met loopen, het is beter om die toestand bovenaan te controleren.
Omwille van de leesbaarheid, als de lus op de proef is, is deze veel intuïtiever.
Dus laat die lus aan het begin controleren, gebruik een voor of een tijdje.
En in veel gevallen is het belangrijk dat de lus volledig wordt overgeslagen als de test in eerste instantie niet wordt gehaald.
Nogmaals, omdat dat het geval is, moet de test bovenaan staan. Je moet niet altijd minstens één keer uitvoeren.
Voor het grootste deel wil je misschien altijd niet uitvoeren.
Je moet dus een tijdje een a gebruiken.
Nu komt de vraag goed welke ik moet gebruiken, een tijdje.
Het is echt een kwestie van persoonlijke voorkeur. Het maakt niet uit, want zoals ik
aan het begin van deze lezing al zei, alles wat je in een tijdje kunt doen, kun je in een voor doen.
Dus als je de for-lus gewoon beter vindt, is de for soms een
beetje sneller omdat alle wijziging van de lusbesturing en de initialisatie en de
exit-voorwaarde allemaal op één regel kunnen staan.
Maar het is echt aan jou.
Meestal gebruik ik de for-lus voor tegengestuurde lussen.
Maar nogmaals, je kunt hetzelfde gebruiken. Als je echt een for-lus wilt gebruiken
en het als een tijdje wilt laten lijken, heb je
gewoon niet de eerste en de derde uitdrukking,
je hebt alleen de enkele. Dus de puntkomma voor puntkommatests is hetzelfde als while-test.
Dus dit laat je alleen maar zien dat de for in the while hetzelfde kan doen, alleen de
syntaxis een beetje veranderen.
Als u daadwerkelijk een while-lus wilt gebruiken, maar u wilt dat deze zich gedraagt
als een for-lus, dan zou u de initialisatie vooraf laten gaan en update-instructies in de body opnemen.
Dus wat je zou doen is zoiets als dit en je doet dit meestal altijd voor een while-lus.
Maar dit is het equivalent van een for-lus. De initialisatie is buiten de lus
van de regelvariabele, de regelvariabele van de lus.
De testconditie staat tussen haakjes, en dan werk
je die regelvariabele van de lus bij in de hoofdtekst van de while-lus.
En dat is hetzelfde als de for loop initialisatie test update en
dan de body. Er is geen verschil.
Nogmaals, zoals ik al zei, gebruik ik de for-lus misschien iets meer voor counter-control loops.
Maar ik zal zowel de voor als de tijd door elkaar gebruiken, afhankelijk van hoe ik me die dag voel.
Dus een for-lus is misschien iets geschikter als u een
variabele op één regel wilt initialiseren en bijwerken.
Een while-lus is beter als de omstandigheden anders zijn.
Nogmaals, tegencontrolelussen voor, schildwachtcontrolelussen misschien de while-lus.
En hier is een voorbeeld van een while-lus met een sentinel-regellus
en een for-lus die hetzelfde opnieuw doet of een for-lus voor een gecontroleerde teller.
Hoewel de lus vele malen kan worden uitgevoerd
op basis van wat de gebruiker invoert, wordt de for-lus tegengestuurd.
Dus dit is de tijd om te doen. Hopelijk is dit duidelijk.
Raak vertrouwd met deze lussen omdat je vaak code wilt herhalen.
In het gesprek een beetje over geneste lussen en ook een beetje andere
mechanismen om een lus te verlaten met een pauze of door
te gaan. Dank u.