1
00:00:07,370 --> 00:00:09,760
[Powered by Google Translate] TOMMY MACWILLIAM: La oss snakke om looper, en av de vanligste

2
00:00:09,760 --> 00:00:13,380
programmering konstruerer vi får se hele CS50.

3
00:00:13,380 --> 00:00:15,570
Vi vil bruke løkker når vi ønsker å utføre en

4
00:00:15,570 --> 00:00:17,200
oppgave mer enn én gang.

5
00:00:17,200 --> 00:00:20,700
For eksempel kan vi ønsker å skrive ut "hei" 100 ganger eller skrive ut

6
00:00:20,700 --> 00:00:22,700
ut alle bokstavene i alfabetet.

7
00:00:22,700 --> 00:00:26,030
I begge disse tilfellene har vi en ting vi ønsker å gjøre

8
00:00:26,030 --> 00:00:28,700
flere ganger, skrive noe ut.

9
00:00:28,700 --> 00:00:31,970
Men hva vi skrive ut hver gang kan variere.

10
00:00:31,970 --> 00:00:34,530
Så vi kan gjøre noe litt annerledes på hver

11
00:00:34,530 --> 00:00:37,820
gjentakelse eller kjøre gjennom, av løkken.

12
00:00:37,820 --> 00:00:41,280
Vi får se tre forskjellige typer sløyfer i C, mens

13
00:00:41,280 --> 00:00:44,700
looper, for looper, og gjøre mens sløyfer.

14
00:00:44,700 --> 00:00:47,850
Om disse tre typer sløyfer har en annen syntaks,

15
00:00:47,850 --> 00:00:50,630
ideene bak dem er den samme.

16
00:00:50,630 --> 00:00:53,930
Vi vil definere noen blokk med kode innen klammeparentes,

17
00:00:53,930 --> 00:00:57,810
kalt kroppen av loopen, at vi ønsker å bli utført

18
00:00:57,810 --> 00:00:59,790
et antall ganger.

19
00:00:59,790 --> 00:01:03,370
Ved å endre verdiene av variablene i kroppen, vi

20
00:01:03,370 --> 00:01:07,570
kan gjøre våre sløyfe gjøre noe annerledes hver gang det kjøres.

21
00:01:07,570 --> 00:01:10,750
Med noen loop vi skriver, vil vi også må bestemme når

22
00:01:10,750 --> 00:01:12,400
sløyfe skal slutte.

23
00:01:12,400 --> 00:01:15,650
Hvis vi ikke gjør det, så våre tillitsverdig datamaskinen vil fortsette

24
00:01:15,650 --> 00:01:19,040
å kjøre som sløyfe før vi dreper programmet.

25
00:01:19,040 --> 00:01:22,490
I Scratch, kunne vi bruke gjenta n ganger

26
00:01:22,490 --> 00:01:24,600
blokkere å opprette en løkke.

27
00:01:24,600 --> 00:01:28,200
Alle brikkene innenfor en blokk som sa gjenta 10

28
00:01:28,200 --> 00:01:30,130
ville bli kjørt 10 ganger.

29
00:01:30,130 --> 00:01:34,160
Og så vil vi gå videre til brikkene etter at loop.

30
00:01:34,160 --> 00:01:38,140
Så vår stopp tilstanden var rett og slett har denne blokken vært

31
00:01:38,140 --> 00:01:39,830
kjøre 10 ganger.

32
00:01:39,830 --> 00:01:43,900
Så la oss gjenskape dette i C. For Scratch å sikre

33
00:01:43,900 --> 00:01:46,920
at bitene innenfor gjenta blokken utføres

34
00:01:46,920 --> 00:01:51,180
nøyaktig 10 ganger, må Scratch å holde styr på hver

35
00:01:51,180 --> 00:01:53,750
utførelsen av gjenta blokken.

36
00:01:53,750 --> 00:01:56,790
For å holde styr på hvor mange ganger vår sløyfe kroppen har vært

37
00:01:56,790 --> 00:02:00,360
henrettet, la oss lage en variabel kalt jeg.

38
00:02:00,360 --> 00:02:03,400
Vi begynner jeg av på null, siden loop

39
00:02:03,400 --> 00:02:04,650
har ikke blitt kjørt enda.

40
00:02:10,009 --> 00:02:10,949
OK

41
00:02:10,949 --> 00:02:15,560
Nå skal vi bruke mens nøkkelord for å starte av vår loop.

42
00:02:20,100 --> 00:02:24,180
Nå trenger vi å finne ut når vår løkke vil stoppe, men

43
00:02:24,180 --> 00:02:26,730
la oss la dette for nå og deretter komme tilbake til det.

44
00:02:30,970 --> 00:02:32,150
OK.

45
00:02:32,150 --> 00:02:35,260
Innsiden av loop, la oss bare ut en melding ut, som

46
00:02:35,260 --> 00:02:38,535
"Hei". Vi kan bruke printf funksjonen for dette.

47
00:02:48,400 --> 00:02:49,230
OK.

48
00:02:49,230 --> 00:02:54,210
Så nå skal vi registrere at en gjentakelse av loopen kroppen har

49
00:02:54,210 --> 00:02:55,750
blitt henrettet.

50
00:02:55,750 --> 00:03:00,320
Vi kan gjøre det ved å legge til en til, eller økes, vår teller

51
00:03:00,320 --> 00:03:01,740
variabel,. jeg

52
00:03:01,740 --> 00:03:09,180
Å gjøre det, kan vi si at jeg er lik i pluss 1 eller mer

53
00:03:09,180 --> 00:03:16,520
enkelt, jeg pluss pluss.

54
00:03:16,520 --> 00:03:17,320
Flott.

55
00:03:17,320 --> 00:03:21,810
Så nå kan vi se at hver gang vår sløyfe er kjørt, vår

56
00:03:21,810 --> 00:03:24,500
tellervariabelen går opp med en.

57
00:03:24,500 --> 00:03:29,410
Så vi vet nøyaktig hvor mange iterasjoner vi har kjørt så langt.

58
00:03:29,410 --> 00:03:31,630
Etter en iterasjon av sløyfen, vår verdi

59
00:03:31,630 --> 00:03:34,270
av jeg vil være en.

60
00:03:34,270 --> 00:03:37,460
Etter to iterasjoner, vil jeg være to.

61
00:03:37,460 --> 00:03:42,640
Og etter 10 gjentakelser, vil jeg være 10 år.

62
00:03:42,640 --> 00:03:46,780
Så hvis vi ønsker å kjøre denne sløyfen nøyaktig 10 ganger, deretter

63
00:03:46,780 --> 00:03:49,240
dette er når vi ønsker å stoppe.

64
00:03:49,240 --> 00:03:53,860
Så vi ønsker å kjøre denne sløyfen mens jeg er mindre enn 10, og

65
00:03:53,860 --> 00:03:57,630
det er akkurat hva vi skal skrive, mens jeg

66
00:03:57,630 --> 00:04:02,450
er mindre enn 10 år.

67
00:04:02,450 --> 00:04:06,380
Denne tilstanden ser ut akkurat som de forholdene vi brukte i om

68
00:04:06,380 --> 00:04:07,830
else blokker.

69
00:04:07,830 --> 00:04:11,690
Etter at kroppen av loop er blitt henrettet, vårt program

70
00:04:11,690 --> 00:04:14,690
vil hoppe tilbake til løkker tilstand.

71
00:04:14,690 --> 00:04:17,290
Hvis betingelsen er sann, så kroppen av

72
00:04:17,290 --> 00:04:18,990
Løkken vil bli kjørt på nytt.

73
00:04:18,990 --> 00:04:22,190
Hvis tilstanden er ikke lenger sant, så vår løkken ikke vil være

74
00:04:22,190 --> 00:04:25,700
kjøre lenger og vil gå videre til neste linje med kode

75
00:04:25,700 --> 00:04:27,876
under loop.

76
00:04:27,876 --> 00:04:28,550
OK.

77
00:04:28,550 --> 00:04:30,740
Så la oss ta en titt på en annen type

78
00:04:30,740 --> 00:04:33,000
loop, for loop.

79
00:04:33,000 --> 00:04:37,310
Ved siden av mens søkeordet, i parentes, hadde vi en ting,

80
00:04:37,310 --> 00:04:39,840
den tilstanden som måtte være til stede på

81
00:04:39,840 --> 00:04:42,010
løkke kroppen som skal kjøres.

82
00:04:42,010 --> 00:04:45,440
Det betyr at vi måtte lage våre tellervariabelen utenfor

83
00:04:45,440 --> 00:04:48,760
av loopen og husk å øke det på et tidspunkt

84
00:04:48,760 --> 00:04:51,050
innsiden av løkken.

85
00:04:51,050 --> 00:04:54,320
Toppteksten for våre for loop, på den annen side, har tre

86
00:04:54,320 --> 00:04:58,510
deler, som hver vil skilles med semikolon.

87
00:04:58,510 --> 00:05:01,950
I vår første tredjedel, kan vi erklære noen counter eller hjelper

88
00:05:01,950 --> 00:05:05,000
variabler vi ønsker å bruke i loop.

89
00:05:05,000 --> 00:05:07,350
I praksis kan dette være veldig nyttig.

90
00:05:07,350 --> 00:05:10,590
Vi trenger ikke den variabelen, i, etter mens vår

91
00:05:10,590 --> 00:05:13,650
løkke har kjørt, så vi egentlig ikke bør ha for å erklære det

92
00:05:13,650 --> 00:05:15,810
utenfor sløyfen.

93
00:05:15,810 --> 00:05:19,080
Den andre tredje vil være den tilstand som må være sant

94
00:05:19,080 --> 00:05:21,850
for kroppen å bli henrettet igjen, akkurat som

95
00:05:21,850 --> 00:05:23,330
i vår mens loop.

96
00:05:23,330 --> 00:05:26,350
I vår siste tredjedel, kan vi kjøre en uttalelse som vil bli

97
00:05:26,350 --> 00:05:30,270
utføres etter hver iterasjon av loopen, så vi har ikke

98
00:05:30,270 --> 00:05:32,710
å bygge den inn i løkken kroppen.

99
00:05:32,710 --> 00:05:38,390
Så la oss skrive en for løkke som teller ned fra 5 til 1.

100
00:05:38,390 --> 00:05:41,790
Vi begynner med den for søkeordet.

101
00:05:41,790 --> 00:05:44,680
Vi kan lage en tellervariabelen først, som vi vil

102
00:05:44,680 --> 00:05:47,840
satt til 5 denne gangen siden vi teller ned,

103
00:05:47,840 --> 00:05:50,110
etterfulgt av et semikolon.

104
00:05:50,110 --> 00:05:53,660
Neste er vår tilstand, som vi vil komme tilbake til.

105
00:05:53,660 --> 00:05:57,540
Tredje, vil vi gjerne minske vår tellervariabelen etter

106
00:05:57,540 --> 00:05:59,620
hver iterasjon av sløyfen.

107
00:05:59,620 --> 00:06:04,740
Så i stedet for å si jeg pluss pluss, vil vi si jeg minus minus.

108
00:06:04,740 --> 00:06:05,300
OK.

109
00:06:05,300 --> 00:06:09,490
Så vi vil at loopen kroppen til å kjøre mens jeg fortsatt er

110
00:06:09,490 --> 00:06:11,960
større enn 0.

111
00:06:11,960 --> 00:06:16,160
I kroppen av loopen, la oss skrive ut verdien av i.

112
00:06:16,160 --> 00:06:20,480
For å gjøre dette, vil vi bruke printf funksjonen, bruker% d

113
00:06:20,480 --> 00:06:21,650
plassholder.

114
00:06:21,650 --> 00:06:24,820
Husk at det plassholderen bli erstattet med

115
00:06:24,820 --> 00:06:27,040
Verdien av jeg.

116
00:06:27,040 --> 00:06:32,060
Til slutt, la oss legge til en uttalelse etter vår for loop.

117
00:06:32,060 --> 00:06:35,850
Når vi kjører denne sløyfen, vil jeg starte på 5,

118
00:06:35,850 --> 00:06:38,070
så 5 vil bli skrevet ut.

119
00:06:38,070 --> 00:06:42,000
Når jeg kommer til 0, fortsettelsen tilstand, er jeg

120
00:06:42,000 --> 00:06:44,450
større enn 0, vil ikke lenger holde.

121
00:06:44,450 --> 00:06:47,330
Så vår løkke vil stanse henrettelsene, og vi vil se

122
00:06:47,330 --> 00:06:49,850
setningen etter løkken.

123
00:06:49,850 --> 00:06:51,340
Så la oss kjøre denne koden.

124
00:06:51,340 --> 00:06:52,700
Først vil vi sette sammen en

125
00:06:52,700 --> 00:06:56,460
countdown.c med lag nedtelling.

126
00:06:56,460 --> 00:06:59,320
Nå kan vi kjøre denne koden med. / Nedtelling.

127
00:07:02,340 --> 00:07:06,040
I begge mens looper og for looper, vår videreføring

128
00:07:06,040 --> 00:07:09,010
tilstand vil bli sjekket før kroppen

129
00:07:09,010 --> 00:07:10,960
av løkke kjøres.

130
00:07:10,960 --> 00:07:13,840
Det betyr at hvis vår tilstand er i utgangspunktet ikke

131
00:07:13,840 --> 00:07:18,100
sant, så kroppen av loop aldri vil bli kjørt.

132
00:07:18,100 --> 00:07:22,060
Så det er noen ganger nyttig å sjekke tilstanden etter

133
00:07:22,060 --> 00:07:25,150
legeme av loopen snarere enn før den.

134
00:07:25,150 --> 00:07:28,270
Så la oss skrive en loop for å be brukeren for en rekke

135
00:07:28,270 --> 00:07:30,990
inntil et positivt tall er levert.

136
00:07:30,990 --> 00:07:34,740
Hvis brukeren innganger et negativt tall, vil vi ønsker å spørre dem

137
00:07:34,740 --> 00:07:36,260
for et annet nummer.

138
00:07:36,260 --> 00:07:38,940
Så vi vil ha denne meldingen å være inne i

139
00:07:38,940 --> 00:07:41,050
organ av løkken.

140
00:07:41,050 --> 00:07:44,730
Imidlertid, når sløyfen kjøres for første gang, brukeren

141
00:07:44,730 --> 00:07:46,750
har ikke gitt oss nummeret ennå.

142
00:07:46,750 --> 00:07:49,640
Slik at det ikke fornuftig å sjekke om det er positivt.

143
00:07:49,640 --> 00:07:54,020
I stedet vil vi ønsker å sjekke nummeret etter kroppen

144
00:07:54,020 --> 00:07:55,720
løkken er kjørt.

145
00:07:55,720 --> 00:08:00,310
Vi kan gjøre dette med en do mens loop.

146
00:08:00,310 --> 00:08:03,560
Først vil vi lage en variabel, n, som vil holde

147
00:08:03,560 --> 00:08:05,230
brukerens input.

148
00:08:05,230 --> 00:08:09,960
Nå skal vi bruke do søkeord, etterfulgt av klammeparentes som

149
00:08:09,960 --> 00:08:12,930
vil starte kroppen av loop.

150
00:08:12,930 --> 00:08:16,230
I kroppen, kan vi be brukeren om et tall med

151
00:08:16,230 --> 00:08:18,480
GetInt funksjon.

152
00:08:18,480 --> 00:08:23,230
Nå vil vi ønsker kroppen av denne sløyfen for å utføre igjen hvis

153
00:08:23,230 --> 00:08:28,370
brukeren har skrevet et negativt tall, så vi vil si mens n

154
00:08:28,370 --> 00:08:30,420
er mindre enn 0.

155
00:08:30,420 --> 00:08:33,140
Legg merke til semikolon her etter mens uttalelse.

156
00:08:38,909 --> 00:08:40,679
Så la oss kjøre denne koden.

157
00:08:40,679 --> 00:08:44,780
Først vil vi kompilere dette med at positive.

158
00:08:44,780 --> 00:08:49,340
Nå kan vi kjøre programmet med. / Positiv.

159
00:08:49,340 --> 00:08:52,660
Hvis vi gir dette programmet et negativt tall, som negativ

160
00:08:52,660 --> 00:08:56,560
4, så vi vil bli spurt igjen for en rekke siden

161
00:08:56,560 --> 00:09:00,490
tilstanden gjør våre mens loop var sant.

162
00:09:00,490 --> 00:09:04,690
Når vi gi et positivt tall, som 8, deretter

163
00:09:04,690 --> 00:09:08,560
tilstanden gjør våre mens loop vil ikke lenger være sant.

164
00:09:08,560 --> 00:09:12,080
Så løkken ikke vil bli utført på nytt.

165
00:09:12,080 --> 00:09:15,290
Og det er det for de tre typer sløyfer vi skal bruke i C.

166
00:09:15,290 --> 00:09:18,840
Mitt navn er Tommy, og dette er CS50.