[Powered by Google Translate] TOMMY MACWILLIAM: La oss snakke om looper, en av de vanligste
programmering konstruerer vi får se hele CS50.
Vi vil bruke løkker når vi ønsker å utføre en
oppgave mer enn én gang.
For eksempel kan vi ønsker å skrive ut "hei" 100 ganger eller skrive ut
ut alle bokstavene i alfabetet.
I begge disse tilfellene har vi en ting vi ønsker å gjøre
flere ganger, skrive noe ut.
Men hva vi skrive ut hver gang kan variere.
Så vi kan gjøre noe litt annerledes på hver
gjentakelse eller kjøre gjennom, av løkken.
Vi får se tre forskjellige typer sløyfer i C, mens
looper, for looper, og gjøre mens sløyfer.
Om disse tre typer sløyfer har en annen syntaks,
ideene bak dem er den samme.
Vi vil definere noen blokk med kode innen klammeparentes,
kalt kroppen av loopen, at vi ønsker å bli utført
et antall ganger.
Ved å endre verdiene av variablene i kroppen, vi
kan gjøre våre sløyfe gjøre noe annerledes hver gang det kjøres.
Med noen loop vi skriver, vil vi også må bestemme når
sløyfe skal slutte.
Hvis vi ikke gjør det, så våre tillitsverdig datamaskinen vil fortsette
å kjøre som sløyfe før vi dreper programmet.
I Scratch, kunne vi bruke gjenta n ganger
blokkere å opprette en løkke.
Alle brikkene innenfor en blokk som sa gjenta 10
ville bli kjørt 10 ganger.
Og så vil vi gå videre til brikkene etter at loop.
Så vår stopp tilstanden var rett og slett har denne blokken vært
kjøre 10 ganger.
Så la oss gjenskape dette i C. For Scratch å sikre
at bitene innenfor gjenta blokken utføres
nøyaktig 10 ganger, må Scratch å holde styr på hver
utførelsen av gjenta blokken.
For å holde styr på hvor mange ganger vår sløyfe kroppen har vært
henrettet, la oss lage en variabel kalt jeg.
Vi begynner jeg av på null, siden loop
har ikke blitt kjørt enda.
OK
Nå skal vi bruke mens nøkkelord for å starte av vår loop.
Nå trenger vi å finne ut når vår løkke vil stoppe, men
la oss la dette for nå og deretter komme tilbake til det.
OK.
Innsiden av loop, la oss bare ut en melding ut, som
"Hei". Vi kan bruke printf funksjonen for dette.
OK.
Så nå skal vi registrere at en gjentakelse av loopen kroppen har
blitt henrettet.
Vi kan gjøre det ved å legge til en til, eller økes, vår teller
variabel,. jeg
Å gjøre det, kan vi si at jeg er lik i pluss 1 eller mer
enkelt, jeg pluss pluss.
Flott.
Så nå kan vi se at hver gang vår sløyfe er kjørt, vår
tellervariabelen går opp med en.
Så vi vet nøyaktig hvor mange iterasjoner vi har kjørt så langt.
Etter en iterasjon av sløyfen, vår verdi
av jeg vil være en.
Etter to iterasjoner, vil jeg være to.
Og etter 10 gjentakelser, vil jeg være 10 år.
Så hvis vi ønsker å kjøre denne sløyfen nøyaktig 10 ganger, deretter
dette er når vi ønsker å stoppe.
Så vi ønsker å kjøre denne sløyfen mens jeg er mindre enn 10, og
det er akkurat hva vi skal skrive, mens jeg
er mindre enn 10 år.
Denne tilstanden ser ut akkurat som de forholdene vi brukte i om
else blokker.
Etter at kroppen av loop er blitt henrettet, vårt program
vil hoppe tilbake til løkker tilstand.
Hvis betingelsen er sann, så kroppen av
Løkken vil bli kjørt på nytt.
Hvis tilstanden er ikke lenger sant, så vår løkken ikke vil være
kjøre lenger og vil gå videre til neste linje med kode
under loop.
OK.
Så la oss ta en titt på en annen type
loop, for loop.
Ved siden av mens søkeordet, i parentes, hadde vi en ting,
den tilstanden som måtte være til stede på
løkke kroppen som skal kjøres.
Det betyr at vi måtte lage våre tellervariabelen utenfor
av loopen og husk å øke det på et tidspunkt
innsiden av løkken.
Toppteksten for våre for loop, på den annen side, har tre
deler, som hver vil skilles med semikolon.
I vår første tredjedel, kan vi erklære noen counter eller hjelper
variabler vi ønsker å bruke i loop.
I praksis kan dette være veldig nyttig.
Vi trenger ikke den variabelen, i, etter mens vår
løkke har kjørt, så vi egentlig ikke bør ha for å erklære det
utenfor sløyfen.
Den andre tredje vil være den tilstand som må være sant
for kroppen å bli henrettet igjen, akkurat som
i vår mens loop.
I vår siste tredjedel, kan vi kjøre en uttalelse som vil bli
utføres etter hver iterasjon av loopen, så vi har ikke
å bygge den inn i løkken kroppen.
Så la oss skrive en for løkke som teller ned fra 5 til 1.
Vi begynner med den for søkeordet.
Vi kan lage en tellervariabelen først, som vi vil
satt til 5 denne gangen siden vi teller ned,
etterfulgt av et semikolon.
Neste er vår tilstand, som vi vil komme tilbake til.
Tredje, vil vi gjerne minske vår tellervariabelen etter
hver iterasjon av sløyfen.
Så i stedet for å si jeg pluss pluss, vil vi si jeg minus minus.
OK.
Så vi vil at loopen kroppen til å kjøre mens jeg fortsatt er
større enn 0.
I kroppen av loopen, la oss skrive ut verdien av i.
For å gjøre dette, vil vi bruke printf funksjonen, bruker% d
plassholder.
Husk at det plassholderen bli erstattet med
Verdien av jeg.
Til slutt, la oss legge til en uttalelse etter vår for loop.
Når vi kjører denne sløyfen, vil jeg starte på 5,
så 5 vil bli skrevet ut.
Når jeg kommer til 0, fortsettelsen tilstand, er jeg
større enn 0, vil ikke lenger holde.
Så vår løkke vil stanse henrettelsene, og vi vil se
setningen etter løkken.
Så la oss kjøre denne koden.
Først vil vi sette sammen en
countdown.c med lag nedtelling.
Nå kan vi kjøre denne koden med. / Nedtelling.
I begge mens looper og for looper, vår videreføring
tilstand vil bli sjekket før kroppen
av løkke kjøres.
Det betyr at hvis vår tilstand er i utgangspunktet ikke
sant, så kroppen av loop aldri vil bli kjørt.
Så det er noen ganger nyttig å sjekke tilstanden etter
legeme av loopen snarere enn før den.
Så la oss skrive en loop for å be brukeren for en rekke
inntil et positivt tall er levert.
Hvis brukeren innganger et negativt tall, vil vi ønsker å spørre dem
for et annet nummer.
Så vi vil ha denne meldingen å være inne i
organ av løkken.
Imidlertid, når sløyfen kjøres for første gang, brukeren
har ikke gitt oss nummeret ennå.
Slik at det ikke fornuftig å sjekke om det er positivt.
I stedet vil vi ønsker å sjekke nummeret etter kroppen
løkken er kjørt.
Vi kan gjøre dette med en do mens loop.
Først vil vi lage en variabel, n, som vil holde
brukerens input.
Nå skal vi bruke do søkeord, etterfulgt av klammeparentes som
vil starte kroppen av loop.
I kroppen, kan vi be brukeren om et tall med
GetInt funksjon.
Nå vil vi ønsker kroppen av denne sløyfen for å utføre igjen hvis
brukeren har skrevet et negativt tall, så vi vil si mens n
er mindre enn 0.
Legg merke til semikolon her etter mens uttalelse.
Så la oss kjøre denne koden.
Først vil vi kompilere dette med at positive.
Nå kan vi kjøre programmet med. / Positiv.
Hvis vi gir dette programmet et negativt tall, som negativ
4, så vi vil bli spurt igjen for en rekke siden
tilstanden gjør våre mens loop var sant.
Når vi gi et positivt tall, som 8, deretter
tilstanden gjør våre mens loop vil ikke lenger være sant.
Så løkken ikke vil bli utført på nytt.
Og det er det for de tre typer sløyfer vi skal bruke i C.
Mitt navn er Tommy, og dette er CS50.