[Powered by Google Translate] TOMMY MacWilliam: Laten we praten over loops, een van de gemeenschappelijke
programmering construeert we zullen zien in heel CS50.
We gebruiken lussen als we willen een uit te voeren
taak meer dan eens.
Bijvoorbeeld, we willen "hi" 100 keer of print print
alles uit de letters van het alfabet.
In beide gevallen hebben we een ding dat we willen doen
meerdere keren, af te drukken iets uit.
Wat we echter af te drukken elke keer kan variëren.
Dus we kunnen doen iets anders op elke
iteratie, of lopen door, van de lus.
We zullen zien drie verschillende soorten lussen in C, terwijl
loops, voor loops, en te doen terwijl loops.
Hoewel deze drie soorten lussen hebben een andere structuur,
het idee achter zijn hetzelfde.
We definiëren een aantal blok van code binnen accolades,
riep de body van de lus, die we willen worden uitgevoerd
een aantal malen.
Door de waarden van variabelen in het lichaam,
kunnen onze lus iets anders elke keer het wordt gerund.
Bij elke lus we schrijven, zullen we ook moeten beslissen wanneer de
lus zal stoppen.
Als we dat niet doen, dan onze vertrouwde computer zal blijven
om die lus lopen tot we dood het programma.
In Scratch, kunnen we gebruik maken van de herhaling n keer
blokkeren om een ​​lus te maken.
Alle stukken in een blok dat herhaling 10 zei
zou worden uitgevoerd 10 keer.
En dan zouden we overgaan tot de stukken na die lus.
Dus onze stop conditie was gewoon, is dit blok is
lopen 10 keer.
Dus laten we opnieuw deze in C. Om Scratch te verzekeren
dat de stukken in de repeat blok uitgevoerd
precies 10 keer, Scratch moet bijhouden van elk
uitvoering van de herhaling blok.
Om bij te houden hoe vaak onze lus lichaam is
uitgevoerd, laten zien, maken een variabele genaamd i.
We beginnen i uit bij nul, aangezien onze lus
is nog niet uitgevoerd.
OK
Nu zullen we gebruik maken van de tijdens het trefwoord om te beginnen onze lus.
Nu zullen we moeten uitzoeken wanneer onze lus zal stoppen, maar
laten we dit laten voor nu en dan terug te komen om het te.
Oke.
Binnenkant van onze lus, laten we een bericht uit te printen, zoals
"Hi". We kunnen gebruik maken van de printf functie voor dit.
Oke.
Dus nu zullen we constateren dat een iteratie van de lus lichaam heeft
uitgevoerd.
We kunnen dat doen door het toevoegen van 1 tot en met, of verhogen, onze teller
variabele i.
Daarvoor kunnen we zeggen i gelijk is aan i plus 1 of meer
gewoon, i plus plus.
Geweldig.
Dus nu kunnen we zien dat iedere keer onze lus wordt uitgevoerd, onze
teller variabele stijgt met een.
Dus we weten precies hoeveel iteraties we tot nu toe uit te voeren.
Na een herhaling van de lus, onze waarde
i op 1.
Na twee iteraties, zal ik 2.
En na 10 iteraties, zal ik 10.
Dus, als we willen deze lus loopt precies 10 keer, dan
dit is wanneer we willen stoppen.
Dus we willen deze lus draaien terwijl ik minder dan 10, en
dat is precies wat we schrijven, terwijl ik
minder dan 10.
Deze voorwaarde ziet er net als de voorwaarden die wij gebruiken in als
anders blokken.
Nadat het lichaam van onze lus is uitgevoerd, ons programma
zal terug te springen naar de lussen conditie.
Als de conditie waar is, dan is het lichaam van de
lus zal opnieuw worden uitgevoerd.
Als de conditie niet meer het geval, dan is onze lus zal niet
lopen meer en zal doorgaan naar de volgende regel code
onder onze lus.
Oke.
Dus laten we eens een kijkje nemen op een tweede type
lus, de lus.
Naast de tijdens het trefwoord, tussen haakjes, hadden we een ding,
voorwaarde dat nodig waar de
lus worden uitgevoerd.
Dat betekent dat we onze counter variabele te creëren buiten
van de lus en vergeet niet om deze te verhogen op een bepaald punt
binnenzijde van de lus.
De header van onze lus, daarentegen, heeft drie
delen, die elk worden gescheiden door een puntkomma.
In ons eerste derde, kunnen we melding van al hun balie of helper
variabelen willen we gebruiken in onze kring.
In de praktijk kan dit echt nuttig.
We hebben echt die variabele, i, niet nodig na onze terwijl
lus is uitgevoerd, dus we moeten echt niet te verklaren
buiten de lus.
Het tweede derde zal de voorwaarde dat moet worden waar
voor het lichaam opnieuw te worden uitgevoerd, zoals
in onze while-lus.
In onze laatste derde deel, kunnen wij een verklaring dat zal worden
uitgevoerd na elke iteratie van de lus, zodat we niet hebben
om het in te bouwen in de lus.
Dus laten we een schrijven voor lus die naar beneden telt vanaf 5 tot 1.
We beginnen met de voor zoekwoord.
We kunnen een teller variabele eerste, die we zullen
ingesteld op 5 dit keer aangezien we aftellen,
gevolgd door een puntkomma.
Volgende is onze toestand, die we zullen terug te komen.
Ten derde willen we onze counter variabele te verlagen na
elke iteratie van de lus.
Dus in plaats van te zeggen dat ik plus plus, zullen we zeggen dat ik min min.
Oke.
Dus we willen dat de lus te lopen terwijl ik nog
groter dan 0.
In het lichaam van de lus, laten we afdrukken van de waarde van i.
Om dit te doen, zullen we gebruik maken van de printf functie, met behulp van de% d
tijdelijke aanduiding.
Denk er aan dat tijdelijke aanduiding vervangen door de
waarde van i.
Tot slot voegen we een verklaring na onze for-lus.
Wanneer we deze lus lopen, zal ik beginnen bij 5,
zo 5 zal worden afgedrukt.
Zodra ik krijgt op 0, de voortzetting conditie, i
groter dan 0, zal niet langer vasthouden.
Dus onze lus stopt de uitvoering, en we zullen zien de
verklaring na de lus.
Dus laten we deze code uitvoert.
Eerst zullen we de samenstelling van een
countdown.c met make aftellen.
Nu kunnen we deze code uitvoeren met. / Countdown.
In beide while loops en voor loops, onze voortzetting
voorwaarde zal gecontroleerd worden alvorens het lichaam
de lus wordt uitgevoerd.
Dat betekent dat als onze voorwaarde niet aanvankelijk
waar is, dan is het lichaam van onze lus zal nooit worden uitgevoerd.
Dus het is soms handig om de conditie te controleren na de
body van de lus dan daarvoor.
Dus laten we schrijven een lus aan de gebruiker om een ​​aantal vragen
tot een positief getal wordt toegevoerd.
Als de gebruiker een negatief getal is, dan willen we hen te vragen
voor een ander nummer.
Dus we willen deze prompt te worden binnen de
lichaam van de lus.
Echter, wanneer de lus wordt uitgevoerd voor de eerste keer de gebruiker
heeft ons niet gegeven een aantal nog niet.
Dus het heeft geen zin om te controleren of het positief.
In plaats daarvan zullen we het nummer wilt controleren nadat het lichaam van
de lus wordt uitgevoerd.
We kunnen dit doen met een doe while lus.
Eerst maken we een variabele, n, dat zal houden
invoer van de gebruiker.
Nu gebruiken we de do trefwoord, gevolgd door accolades die
zal beginnen het lichaam van onze lus.
In het lichaam, kunnen we de gebruiker vragen om een ​​aantal met de
GetInt functie.
Nu, we willen het lichaam van deze lus om opnieuw uit te voeren als
de gebruiker heeft ingevoerd een negatief getal, dus we zullen zeggen, terwijl n
kleiner is dan 0.
Hier zie je de puntkomma na de while-opdracht.
Dus laten we deze code uitvoert.
Eerst zullen we compileren dit met make positief.
Nu kunnen we het programma met. / Positief.
Als we dit programma een negatief getal, zoals negatieve
4, dan zullen we weer gevraagd worden om een ​​aantal sinds de
toestand van onze doe while lus waar was.
Nadat we een positief getal, als 8, dan
toestand van onze do while loop niet langer waar.
Dus de lus wordt niet opnieuw uitgevoerd.
En dat is het voor de drie soorten loops gebruiken we in C.
Mijn naam is Tommy, en dit is CS50.