Hallo, en welkom terug.
Ik ga het nog even hebben over de controlestroom.
Dus laten we meteen in lussen duiken die code herhalen.
Eerst gaan we hierover praten voor de lus.
De for-lus gaat helemaal over
het herhalen van code. Dus ter herinnering: het herhalen van
code is een manier om geen duplicatie toe
te staan en je voert misschien meer dan één soortgelijke code tegelijk
uit.
Dus de programmeertaal c heeft bepaalde constructies die zijn ontworpen voor de
taal die je kunt gebruiken als je code wilt herhalen.
En dit stelt u in staat om een reeks uitspraken te herhalen totdat aan een bepaalde voorwaarde is voldaan.
Het is dus vergelijkbaar met de for-lus en dat je een Booleaanse uitdrukking,
een voorwaarde, gaat evalueren. Je kunt niet eeuwig rennen.
Als je voor altijd in een lus loopt, betekent dit dat het een oneindige lus is.
En er zijn slechts bepaalde tijden dat u dat meestal
opnieuw wilt doen, bijvoorbeeld om iets te monitoren of naar iets te luisteren.
Dus het aantal keren dat een lus wordt herhaald, kan eenvoudig per account worden beheerd.
Er zijn 2 soorten loops die
je kunt doen, een counter control loop of zoals een sentinel control loop noemen ze dat.
Een tegenregellus betekent dat de lus 10
keer, 20 keer, 30 keer, een bepaalde hoeveelheid tijd loopt.
Het herhaalt hetzelfde instructieblok een aantal keer in
de lus.
U kunt een ander type lus hebben waar deze niet wordt gecontroleerd.
Het kan 5 keer lopen, het kan een 100 lopen, het kan er 20
willen, het hangt allemaal af van een voorwaarde, een variabele of zoiets. U kunt bijvoorbeeld een lus uitvoeren die zegt
dat ik mijn lus keer op keer ga uitvoeren totdat de
gebruiker quit invoert.
Dus totdat de variabele verandert om te stoppen. Het is niet tegengestuurd. Het is niet afhankelijk.
Nogmaals, het kan 10 keer worden uitgevoerd, het kan 100 keer worden uitgevoerd.
Dit zijn de 2 verschillende soorten lussen. En dus zal ik voorbeelden van beide geven,
maar denk hier eens over na op een hoog niveau, wanneer zou ik de code willen herhalen?
Nou, misschien wil ik de code 5 keer herhalen, een bepaalde hoeveelheid tijd, een
definitieve hoeveelheid tijd of ik wil misschien een code plaatsen
op basis van een bepaalde voorwaarde die door een gebruiker is ingevoerd, en dat wordt sentinel genoemd.
Onze for-lus heeft het for-sleutelwoord. Het wordt gebruikt om een bepaald aantal
keren uit te voeren. Het wordt meestal gebruikt voor tegencontrole, maar dat hoeft niet.
U kunt het gebruiken voor een tegenregellus of een schildwacht voor een regellus.
Het is aan jou. Maar veel van de voorbeelden in
veel van de praktijk zijn tegengestuurd, een bepaald aantal keren.
Als u bijvoorbeeld de cijfers van 1 tot 10 wilt weergeven, gebruikt u de for-lus.
Je zou niet 10 regels code willen
schrijven met dezelfde printf-instructie daar met een ander nummer.
Dat is erg inefficiënt. Het is erg tijdrovend.
Je zou een for-lus gebruiken om code te herhalen.
Wat je zou doen, is dat je zoiets zou doen.
Hier is een inleiding over hoe de for-lus
eruit ziet, de syntaxis.
Je hebt het for-trefwoord en dan heb je deze haakjes.
Nogmaals, de haakjes identificeren verschillende dingen die aan de hand zijn
voor de for-lus.
Dan heb je een haakje en heb je uitspraken tussen de haakjes.
Dus nogmaals, de haakjes vertegenwoordigen de hoofdtekst van de
lus, net zoals de haakjes de hoofdtekst van een if-statement vertegenwoordigen.
Als je één enkele uitspraak hebt, heb je de haakjes niet nodig, maar het is
een goede gewoonte om ze altijd te gebruiken.
Dus in dit voorbeeld zie je het voor-sleutelwoord, dat zou het eerste moeten zijn dat je identificeert.
De bewerking, hoe lang het duurt, wordt bepaald en wat er tussen de haakjes
verschijnt na het for-trefwoord, waar we specifiek op in gaan.
Er zijn eigenlijk 3 verschillende uitdrukkingen daarbinnen.
En je kunt ze herkennen omdat ze gescheiden zijn door de puntkomma.
Dus de puntkomma zegt dat dit een expressie-instructie is.
Dus wat doen die 3 dingen, gaan we beschrijven.
De actie die u wilt herhalen,
bevindt zich in het lichaam van de lus, dat is wat er zo vaak gebeurt.
In dit voorbeeld is de body van de lus printf.
Dus als een voorwaarde als waar wordt beoordeeld, blijft het dat nummer afdrukken.
En nogmaals, voor enkele uitspraken kunt u de accolades weglaten.
Laten we dit dus in detail doornemen.
het algemene patroon voor de for-lus is dat je dit type instructie hebt.
Je hebt een voor en dan heb je een beginvoorwaarde, dit is pseudocode.
Ik probeer de for-lus hier te beschrijven.
Dus de startvoorwaarde is het eerste, alles voor de eerste puntkomma.
Het tweede ding is de voortzettingsvoorwaarde met een
puntkomma aan het einde en dan is het laatste ding tussen de haakjes actie per iteratie.
En ik wil ze allemaal beschrijven. En daarna is in het lichaam de lusverklaring.
De lusverklaring is vrij eenvoudig. Dat zit gewoon in het lichaam.
Dat is de code die wordt uitgevoerd en die elke keer wordt herhaald.
Dat is vrij basaal.
En nogmaals, je kunt de accolades breken als je meerdere uitspraken hebt of de accolades
weglaten als je een enkele instructie hebt.
De startvoorwaarde, dat eerste ding tussen haakjes
voor de eerste puntkomma is meestal, maar niet
altijd, het initialiseert meestal een variabele, de luscontrolevariabele genoemd.
Dat is de variabele waarmee je naar elke iteratie gaat kijken.
Dus de regelvariabele van de lus is meestal een teller van
soms, niet altijd weer, dat wil ik benadrukken, dat hoeft
niet zo te zijn. Maar vaak is het in een
for-lus een teller en wordt bijgehouden hoe vaak de lus is herhaald.
Dat is wat deze startvoorwaarde en de regelvariabele lus doen.
U kunt hier ook meerdere variabelen van hetzelfde type declareren en initialiseren
met de declaratie gescheiden door komma's. U kunt hier dus meerdere initialisatievariabelen
hebben.
Afhankelijk van de c-compiler die u gebruikt,
kunt u deze variabelen mogelijk niet declareren in de for-instructie.
Als je iets onder de C99-compiler gebruikt, moet je de
variabelen buiten de for-instructie declareren en dan zou je ze gewoon hier initialiseren waar
de startvoorwaarde zegt, maar
we zullen enkele van die voorbeelden doornemen.
Maar de beginvoorwaarde is waar u variabelen initialiseert.
Het is de regelvariabele van de lus en het is om die reden genoemd omdat
het bepaalt hoe vaak de lus wordt uitgevoerd wanneer u deze initialiseert.
Het volgende waar ik het over wil hebben is die voortgaande voorwaarde, voortzettingsvoorwaarde, het deel
dat voor de na deze eerste puntkomma in de for-lus staat.
Dit is een logische uitdrukking.
Dit is de voorwaarde die wordt geëvalueerd als waar of onwaar.
Dit is wanneer je in de lus gaat springen of de lus verlaat.
Dit bepaalt of de lus verder moet worden uitgevoerd.
Zolang deze voorwaarde de waarde true heeft, wordt de lus voortgezet
en worden alle instructies in de body uitgevoerd.
Dit controleert meestal de waarde van de regelvariabele van de lus.
Dus je initialiseert de regelvariabele van de lus in de beginvoorwaarde
en dan kijk je naar in de voortzettingsvoorwaarde.
Je kunt hier elke logica of elke rekenkundige uitdrukking plaatsen, zolang je maar weet wat je doet.
De voortzettingsvoorwaarde wordt getest aan het begin van de lus in plaats van aan het einde.
Dit wordt een pre-testlus genoemd.
U zult het verschil merken als we het hebben over de do-while-lus, een post-test-lus.
Maar wat dit betekent is dat de lus-instructie één keer kan worden uitgevoerd, het
kan 0 keer worden uitgevoerd.
Het hangt er allemaal van af of die voortzettingsvoorwaarde al dan niet waar of niet waar is.
Als het onwaar is, ga je het lichaam nooit uitvoeren.
Als het evalueert naar waar, voer je die body minstens één keer uit.
De actie per iteratie die helemaal aan het einde van de for-lus staat na de tweede
puntkomma, die meestal een soort wijziging van de regelvariabele van de lus uitvoert.
Het zal het verhogen of verlagen als het een
lusteller is of als het een schildwachtlus is, kan het de gebruiker vragen om meer invoer in te voeren.
U kunt ook meer dan één wijziging van een variabele doen.
U kunt de regelvariabele van de lus wijzigen en u kunt andere variabelen wijzigen.
Je hoeft ze alleen door komma's te scheiden.
Maar om alles samen te
vatten wat ik heb gezegd, we hebben deze kleine tabel die dat beschrijft.
Maar voordat we daarover praten, laten we een klein voorbeeld bekijken.
Dus hier is een voorbeeld. We hebben het zoekwoord for.
En dan zul je merken dat int I gelijk is aan 1 j gelijk is
aan 2, dat is waar we variabelen initialiseren.
En we initialiseren hier eigenlijk 2 variabelen, gescheiden door de komma,
meestal in een for-lus, meestal slechts één initialiseren, de regelvariabele van de lus.
Maar in dit geval initialiseren we I en j.
En dan na die puntkomma hebben we de voorwaarde.
Wanneer gaan we naar binnen en wanneer gaan we deze lus verlaten.
We gaan naar binnen zolang I kleiner is dan gelijk aan 5.
Dat is onze Booleaanse uitdrukking die evalueert naar waar of onwaar.
En dan na die tweede puntkomma gaan
we die regelvariabele van de lus of elke andere variabele die we ermee bezighouden, wijzigen.
Hier doen we een plus, plus I, dit is
een incrementele operator, prefix I. En dan kennen we j gelijk aan j plus 2.
Dat zal meestal je x-voorwaarde zijn, waarbij die regelvariabele
van de lus wordt gewijzigd.
En dan heeft de body van de lus maar een enkele instructie, dus we hebben de haakjes niet nodig.
We printen gewoon de waarden van I maal j uit.
Dus de uitvoer die door deze code wordt
geproduceerd, wordt de waarden 2, 8, 18, 32 en 50 op een enkele regel.
De eerste iteratie van de lus, I wordt gelijk aan 1, j wordt gelijk aan 2.
En dus gaat het zeggen I maal j, wat 1 maal 2 is en het zal het weergeven.
Het gaat controleren of I niet groter is dan 5, I is niet 1.
Dus het gaat weer omhoog en een tweede keer uitvoeren.
En we wijzigen ook die variabele I in onze laatste verklaring.
Dus in de tweede iteratie van de lus wordt I gelijk aan 2.
En j wordt gelijk aan 2 plus 2 wat gelijk is aan 4.
Dus nu gaan we 2 vermenigvuldigen met 4, wat 8 is
en we gaan het weergeven en dan gaan we controleren of
ik groter dan 5 ben? Nee, ik ben nog 2.
Dus we wijzigen I om nu gelijk te zijn aan 3 voor
de volgende iteratie, en we wijzigen j om gelijk te zijn aan 4 plus
2 wat 6 is.
En dan voor de derde iteratie
van de lus, vermenigvuldigen we I maal J. Dus we zeggen 3 keer 6 en we geven 18 weer.
Voordat we de vierde iteratie uitvoeren, controleren we of I groter is dan 5.
Nee, het is 4. Dan verhogen we het, we zeggen dat het 5 is. Het is gelijk aan 5, dus het zal nog steeds lopen.
Dan doen we er 32, en dan doen we er 50.
Dit is dus een for-statement. U wilt dit uitvoeren en uitvoeren
in de codebrowser en spelen en dingen veranderen.
Maar wat we hier doen, is dat we 3 afzonderlijke dingen doen op een enkele regel code.
We initialiseren de regelvariabele van de lus of andere variabelen.
We hebben onze Booleaanse uitdrukking na onze eerste puntkomma, onze exit-voorwaarde.
En dan wijzigen we de regelvariabele lus en alle andere variabelen die we willen
als dat laatste deel van de for-instructie.
Dus om samen te vatten wat we aan het doen zijn, vond ik deze leuke kleine
handige grafiek uit een boek en ik wilde het je laten zien. Dit vat alles samen.
Die eerste puntkomma initialiseert de regelvariabele van de lus.
Na de eerste puntkomma doen we onze voorwaarde, onze Booleaanse uitdrukking.
En dan na de tweede
puntkomma, wijzigen we die regelvariabele van de lus. En dit is het typische voorbeeld dat je ziet.
Dit is een tegenregellus die begint bij 1 en helemaal doorloopt tot 10.
Dit wordt dus daadwerkelijk 10 keer uitgevoerd.
De sleutel is daar minder dan gelijk aan 10. Dus je gaat relationele operatoren zien als onze voorwaarden,
net zoals we relationele operatoren zagen als onze voorwaarden in onze if-statement.
De sleutel hier is dat je die regelvariabele van de lus wilt wijzigen, anders kom je nooit af.
Dus de plus plus telling is erg belangrijk.
En wat betreft pre- of post-incrementatie, of die plus plus nu voor de variabele of na de variabele
is, je hoeft
je er geen zorgen over te maken, want
het wordt alleen verhoogd of verlaagd na de iteratie van de lus, dus dat doet het niet' Het
maakt niet uit of je plus plus telt of plus plus telt.
En ook nogmaals, afhankelijk van de versie van c die u
voor uw compiler gebruikt, kunt
u mogelijk de variabele telling binnen de for-lus declareren of moet u misschien zeggen
dat int count gelijk is aan 1 of in count buiten de for-lus en initialiseer het dan in de eerste puntkomma.
C99 heeft de initialisatie en declaratie toegevoegd in hetzelfde
deel van de for-lus.
Maar dit is eigenlijk hoe for loop werkt.
Laten we nu een klein voorbeeld bekijken, ik wil je de flexibiliteit van de for-lus laten zien.
Hier is een voorbeeld waarbij we in feite gewoon enkele gehele getallen gaan optellen.
En in dit voorbeeld gaan we de gebruiker vragen een aantal gehele getallen in te voeren die ze willen optellen.
We gaan dat opslaan in een variabele genaamd count.
We hebben nu een for-lus die door al deze
gaat, afhankelijk van het nummer dat ze hebben ingevoerd, zo vaak herhalen.
Dus hier zeggen we 4, we hebben unsigned int, hoeft niet unsigned te zijn want
int I is gelijk aan 1. We initialiseren de regelvariabele van de lus.
En dan zeggen we dat als ik minder is dan te tellen, we dan gaan afsluiten
en dan gaan we het lusmateriaal plus plus I aanpassen.
Dit gaat dus lopen. Nogmaals, de
1 voor het nummer dat de gebruiker heeft ingevoerd, 10 of 20.
En het enige wat we gaan doen is zeggen dat som gelijk is aan som plus 1.
Nu is de for-lus zo krachtig omdat je met de for-lus
veel variabelen kunt wijzigen.
We hoeven die som plus gelijk I niet eens in de body van de for-lus te zetten.
We kunnen het aan het einde van de laatste verklaring plaatsen.
Dus naast het verhogen van I met 1, kunnen we zeggen dat som plus gelijk is aan I plus plus.
Dus we hebben alles in één regel code
gedaan, en dat toont je de flexibiliteit. het is allemaal omdat we de
variabele in de for-instructie zelf kunnen wijzigen. We hoeven die lichaamslijn niet te hebben.
Laten we dus eens kijken naar dit voorbeeld in codeblokken om u te
laten zien hoe u het kunt manipuleren en om te zien wat de uitvoer is.
Dit is ons voorbeeld dat we in de lezing hadden. Ik wil doorgaan en proberen dit te compileren.
En als ik dit compileer, zul je merken dat ik een fout heb.
Er staat dat ik mijn variabele niet in mijn for-statement kan declareren. Dit komt omdat ik een oudere versie
van de c-compiler gebruik. Ik gebruik de C89.
Dit heb je waarschijnlijk niet.
Maar om op te lossen, als je ooit dit type fout ziet, hoef je
het alleen maar buiten de for-lus te wissen. Dus je zegt gewoon niet-ondertekende ik.
En dan in de for-lus, initialiseer je
het, zoiets als dit. Laten we nu proberen te
bouwen en ik moet gewoon enkele van deze formaatspecificaties kwijtraken.
Dus als ik succesvol compileer en dit
programma start, zul je zien hoe de lus werkt.
Het gaat me vragen om de gehele getallen in te voeren die ik wil optellen. Als ik 5 invoer, somt het
1 2 3 4 en 5 op, wat 15 is.
En wat we zouden kunnen doen om dit te debuggen, is dat we een haakje aan de for-lus kunnen toevoegen,
en we kunnen gewoon willen zien hoe vaak het wordt uitgevoerd, we kunnen een printstatement toevoegen om
het niet per se te debuggen, maar gewoon kijken wat er aan de hand is , zouden we inside loop kunnen zeggen.
En dit zal ons vertellen dat de lus 5 keer
loopt omdat hij I gaat lopen om te tellen.
Dus wat ik wil laten zien is hoe vaak dit wordt uitgevoerd. Dus als ik het nu
bouw en uitvoer, ga ik kijken wat er voor elke iteratie gebeurt.
Dus ik ga naar ik zeg 8.
Inside loop, inside loop, inside loop, ik heb geen line feed toegevoegd. Het is dus moeilijk te lezen,
maar de binnenlus wordt 8 keer weergegeven.
En dan tel ik elk van die getallen op in lussen, dus het antwoord
is 36, 1 plus 2 plus 3 plus 4 plus 5 plus 6 plus 7 plus 8.
Hier kun je dus lekker mee spelen. Maar nogmaals,
we initialiseren onze luscontrolevariabele. We controleren de voorwaarde om af te sluiten. We gaan weg zodra we hebben geraakt
wat de gebruiker heeft ingevoerd. Als de gebruiker 8 heeft ingevoerd,
gaan we 8 keer uitvoeren en dan moeten we I wijzigen. Als we ik hier niet zouden wijzigen, zou je een eeuwige lus hebben.
En wat er zou gebeuren als je het programma uitvoerde,
het zou voor altijd blijven draaien.
Dus je zou zien dat nadat je het nummer hebt ingevoerd, je programma nooit zal afsluiten.
Dus stel dat we 6 invoeren, ik druk op enter, kijk wat er aan de
hand is, print gewoon een lus naar binnen. Het is nooit uit.
Het is een oneindige lus. Dus dat laatste is heel erg belangrijk. U wilt altijd uw lusbesturingsvariabele wijzigen.
En nogmaals, de regelvariabele van de lus bepaalt de uitgang, in dit geval I.
Dus de for-lus wordt nogal wat gebruikt.
Het is heel gemakkelijk te gebruiken en je kunt 3 verschillende dingen binnen de lus doen.
Initialiseer de lusbesturingsvariabele, controleer de lusbesturing
van de variabele voor de uitgangsconditie en
wijzig vervolgens die lusbesturingsvariabele.
Dat zijn 3 dingen die je in een lus moet doen, en die je in een enkele instructie kunt doen.
Laat me het nu even hebben over de oneindige lus, heel snel.
Dus ik heb zojuist een oneindige lus gedemonstreerd. Hier kom je nooit uit.
En u bent niet verplicht om parameters in de for loop-instructie te plaatsen.
Je kunt met opzet een oneindige lus schrijven.
De manier waarop u dat zou doen, is door de puntkomma's daar te plaatsen.
Dus je zou een for-lus hebben met 2 puntkomma's.
Als je dat ooit ziet, betekent dat dat je een oneindige lus schrijft.
Normaal gesproken wilt u geen oneindige lussen hebben,
maar er zijn momenten dat de voorwaarde voor het voortzetten van de lus afwezig is.
De lus zal oneindig doorgaan. Dit is soms handig als u gegevens controleert.
Dus als je gegevens in de gaten houdt, heb je daar misschien iets aan.
Meestal, als je een eeuwige lus hebt, heb je meestal ook een
slaapstand, die de uitvoering van het programma pauzeert, misschien voor een seconde, zodat je iets in de gaten houdt.
Het andere geval waarin u een oneindige lus zou kunnen hebben, is als u naar een verbinding luistert.
Dus als je aan het wachten bent en je luistert naar verbinding of als je aan iets trekt om
iets te zien, dan kun je dat doen.
Sommige mensen beweren dat je nooit moet trekken en dat je nooit moet
luisteren, maar dat is een ander argument.
Dat is echt het enige geval voor sommige for-lussen die oneindig zijn.
Vermijd zoveel mogelijk oneindige lussen door die regelvariabele van de lus te wijzigen.
Ik hoop dat dit nuttig was. Dit is de for-lus.
We zullen een for-lus gebruiken in een van onze uitdagingen, zodat we meer vertrouwd raken.
Dank u.