Tip:
Highlight text to annotate it
X
[Powered by Google Translate] TOMMY MACWILLIAM: Lad os tale om sløjfer, en af de fælles
programmering konstruerer vi vil se hele CS50.
Vi vil bruge sløjfer, når vi ønsker at udføre en
opgave mere end én gang.
For eksempel kunne vi ønsker at udskrive "hej" 100 gange eller print
ud af alle bogstaverne i alfabetet.
I begge disse tilfælde har vi én ting, vi ønsker at gøre
flere gange, skrive noget ud.
Men det, vi printe ud hver gang kan variere.
Så vi kan gøre noget lidt anderledes på hver
iteration, eller gennemgå, af løkken.
Vi vil se tre forskellige typer løkker i C, mens
sløjfer, for loops, og gøre, mens sløjfer.
Selvom disse tre typer af sløjfer har en anden syntaks,
idéerne bag dem er de samme.
Vi vil definere nogle blok af kode i krøllede parenteser,
kaldet kroppen af løkken, at vi ønsker at blive henrettet
et antal gange.
Ved at ændre værdierne af variabler, der anvendes i kroppen, vi
kan gøre vores løkke gøre noget anderledes, hver gang det køres.
Med enhver løkke vi skriver, vil vi også nødt til at beslutte, hvornår den
loop stopper med at køre.
Hvis vi ikke gør det, så vores trofaste computer vil fortsætte
at løbe denne løkke indtil vi dræbe programmet.
I Scratch, vi kunne bruge gentagelsen n gange
blok til at skabe en sløjfe.
Alle stykkerne inde i en blok, der sagde gentag 10
ville blive kørt 10 gange.
Og så vil vi gå videre til de stykker efter denne løkke.
Så vores stopbetingelse var simpelthen har denne blok været
køre 10 gange.
Så lad os genskabe denne i C. For Scratch at sikre
at stykkerne i repeat blokken udføres
præcis 10 gange, Scratch nødvendigt at holde styr på hver
udførelsen af den gentagne blok.
For at holde styr på, hvor mange gange vores loop krop har været
henrettet, lad os oprette en variabel kaldet i.
Vi begynder jeg ud på nul, da vores løkke
er ikke blevet kørt endnu.
OK
Nu bruger vi imens søgeord for at starte fra vores løkke.
Nu skal vi bliver nødt til at regne ud, når vores løkke vil stoppe, men
lad os forlade dette for nu og så komme tilbage til det.
Ok.
Inde i vores løkke, så lad os bare udskrive en besked ud, ligesom
"Hi". Vi kan bruge den printf funktion til dette.
Ok.
Så nu vil vi konstatere, at en gentagelse af løkken krop har
blevet henrettet.
Det kan vi gøre ved at lægge 1 til, eller forøgelse, vores counter
variabel, dvs.
For at gøre det, kan vi sige i er lig med i plus 1, eller mere
simpelthen, jeg plus plus.
Great.
Så nu kan vi se, at hver gang vores løkke er kørt, vores
tællervariablen går op for én.
Så vi ved præcis, hvor mange iterationer vi har kørt indtil nu.
Efter en iteration af løkken, vores værdi
af i vil være 1.
Efter to iterationer, vil jeg være 2.
Og efter 10 gentagelser, vil jeg være 10.
Så hvis vi ønsker at køre denne løkke præcis 10 gange, derefter
dette er, når vi ønsker at stoppe.
Så vi ønsker at køre denne løkke, mens jeg er mindre end 10, og
det er præcis, hvad vi vil skrive, mens jeg
er mindre end 10.
Denne betingelse ligner de betingelser, vi brugte i hvis
ellers blokke.
Efter kroppen af vores løkke er blevet udført, vores program
springer tilbage til løkkerne tilstand.
Hvis betingelsen er sand, så selve
loop vil blive kørt igen.
Hvis tilstanden er ikke længere sandt, så er vores løkke vil ikke være
løbe længere og vil gå videre til den næste linje kode
under vores loop.
Ok.
Så lad os tage et kig på en anden type
loop, for-løkken.
Ved siden af, mens søgeord, i parentes, havde vi én ting,
forudsat at skulle være tilfældet for
loop organ, der skal køres.
Det betyder, at vi var nødt til at skabe vores tællervariablen udenfor
af løkken og huske at inkrementere den på et tidspunkt
inde i sløjfen.
Headeren for vores for-løkke, på den anden side, har tre
dele, som hver især vil blive adskilt med et semikolon.
I vores første tredjedel, kan vi erklære ethvert modkrav eller hjælper
variabler vi gerne vil bruge i vores løkke.
I praksis kan dette være virkelig nyttige.
Vi har virkelig ikke brug for variabel, i, efter vores mens
løkke har kørt, så vi virkelig ikke bør have at erklære den
uden for sløjfen.
Den anden tredjedel er den betingelse, der skal være sandt
for kroppen at blive udført igen, lige som
i vores while-løkke.
I vores sidste tredjedel, kan vi køre en erklæring, der vil være
udføres efter hver iteration af løkken, så vi har ingen
at indbygge den i sløjfen organ.
Så lad os skrive en for-løkke, der tæller ned fra 5 til 1.
Vi begynder med den for søgeord.
Vi kan skabe en tællervariablen første, som vi får
sat til 5 denne gang, da vi tæller ned,
efterfulgt af et semikolon.
Next er vores tilstand, som vi vil komme tilbage til.
For det tredje vil vi gerne formindske vores tællervariablen efter
hver iteration af løkken.
Så i stedet for at sige i plus plus, vil vi sige, at jeg minus minus.
Ok.
Så vi ønsker løkken kroppen til at løbe, mens jeg stadig er
større end 0.
I selve sløjfen, lad os udskrive værdien af i.
For at gøre dette, vil vi bruge printf funktion, ved hjælp af% d
pladsholder.
Husk, at pladsholder erstattes med
værdi af i.
Endelig, lad os tilføje en erklæring efter vores for-løkke.
Når vi kører denne løkke, vil jeg starte på 5,
så 5 vil blive udskrevet.
Når jeg kommer til 0, fortsættelsen tilstand, i er
større end 0, vil ikke længere holde.
Så vores løkke vil stoppe udførelsen, og vi vil se den
erklæring efter løkken.
Så lad os køre denne kode.
Først vil vi udarbejde en
countdown.c med lave nedtælling.
Nu kan vi køre denne kode med. / Nedtælling.
I begge mens loops og sløjfer, vores fortsættelse
betingelse vil blive kontrolleret før kroppen
af løkken udføres.
Det betyder, at hvis vores betingelse ikke er oprindelig
sand, så legemet af vores sløjfe aldrig bliver kørt.
Så det er til tider nyttigt at kontrollere tilstanden efter
løkkens krop i stedet for den.
Så lad os skrive en løkke til at bede brugeren om et tal
indtil et positivt tal tilføres.
Hvis brugeren indgange et negativt tal, vil vi gerne bede dem
til et andet nummer.
Så vi vil have denne prompt at være inde i
organ fra sløjfen.
Men når løkken køres for første gang, at brugeren
har ikke givet os det antal endnu.
Så det giver ikke mening at kontrollere, om det er positivt.
I stedet vil vi gerne kontrollere nummeret efter liget af
sløjfen køres.
Vi kan gøre dette med en do while-løkke.
Først vil vi lave en variabel, n, der vil holde
på brugerens indlæsning.
Nu bruger vi do søgeord, efterfulgt af krøllede parenteser, der
vil starte selve vores loop.
I kroppen, kan man bede brugeren om et tal med
GetInt funktion.
Nu vil vi brødtekst denne løkke til at udføre igen, hvis
brugeren har indtastet et negativt tal, så vi vil sige mens n
er mindre end 0.
Læg mærke til semikolon her efter while-sætningen.
Så lad os køre denne kode.
Først vil vi samle dette med make positiv.
Nu kan vi køre programmet med. / Positiv.
Hvis vi giver dette program et negativt tal, ligesom negativ
4, så vil vi blive bedt igen til en antal siden
betingelse af vores do while-løkke var sandt.
Når vi giver et positivt tal, som 8, så
betingelse af vores do while-løkke vil ikke længere være sandt.
Så sløjfen ikke blive udført igen.
Og det er det for de tre typer af sløjfer vi vil bruge i C.
Mit navn er Tommy, og dette er CS50.