1
00:00:07,370 --> 00:00:09,760
[Powered by Google Translate] TOMMY MacWilliam: Laten we praten over loops, een van de gemeenschappelijke

2
00:00:09,760 --> 00:00:13,380
programmering construeert we zullen zien in heel CS50.

3
00:00:13,380 --> 00:00:15,570
We gebruiken lussen als we willen een uit te voeren

4
00:00:15,570 --> 00:00:17,200
taak meer dan eens.

5
00:00:17,200 --> 00:00:20,700
Bijvoorbeeld, we willen "hi" 100 keer of print print

6
00:00:20,700 --> 00:00:22,700
alles uit de letters van het alfabet.

7
00:00:22,700 --> 00:00:26,030
In beide gevallen hebben we een ding dat we willen doen

8
00:00:26,030 --> 00:00:28,700
meerdere keren, af te drukken iets uit.

9
00:00:28,700 --> 00:00:31,970
Wat we echter af te drukken elke keer kan variëren.

10
00:00:31,970 --> 00:00:34,530
Dus we kunnen doen iets anders op elke

11
00:00:34,530 --> 00:00:37,820
iteratie, of lopen door, van de lus.

12
00:00:37,820 --> 00:00:41,280
We zullen zien drie verschillende soorten lussen in C, terwijl

13
00:00:41,280 --> 00:00:44,700
loops, voor loops, en te doen terwijl loops.

14
00:00:44,700 --> 00:00:47,850
Hoewel deze drie soorten lussen hebben een andere structuur,

15
00:00:47,850 --> 00:00:50,630
het idee achter zijn hetzelfde.

16
00:00:50,630 --> 00:00:53,930
We definiëren een aantal blok van code binnen accolades,

17
00:00:53,930 --> 00:00:57,810
riep de body van de lus, die we willen worden uitgevoerd

18
00:00:57,810 --> 00:00:59,790
een aantal malen.

19
00:00:59,790 --> 00:01:03,370
Door de waarden van variabelen in het lichaam,

20
00:01:03,370 --> 00:01:07,570
kunnen onze lus iets anders elke keer het wordt gerund.

21
00:01:07,570 --> 00:01:10,750
Bij elke lus we schrijven, zullen we ook moeten beslissen wanneer de

22
00:01:10,750 --> 00:01:12,400
lus zal stoppen.

23
00:01:12,400 --> 00:01:15,650
Als we dat niet doen, dan onze vertrouwde computer zal blijven

24
00:01:15,650 --> 00:01:19,040
om die lus lopen tot we dood het programma.

25
00:01:19,040 --> 00:01:22,490
In Scratch, kunnen we gebruik maken van de herhaling n keer

26
00:01:22,490 --> 00:01:24,600
blokkeren om een ​​lus te maken.

27
00:01:24,600 --> 00:01:28,200
Alle stukken in een blok dat herhaling 10 zei

28
00:01:28,200 --> 00:01:30,130
zou worden uitgevoerd 10 keer.

29
00:01:30,130 --> 00:01:34,160
En dan zouden we overgaan tot de stukken na die lus.

30
00:01:34,160 --> 00:01:38,140
Dus onze stop conditie was gewoon, is dit blok is

31
00:01:38,140 --> 00:01:39,830
lopen 10 keer.

32
00:01:39,830 --> 00:01:43,900
Dus laten we opnieuw deze in C. Om Scratch te verzekeren

33
00:01:43,900 --> 00:01:46,920
dat de stukken in de repeat blok uitgevoerd

34
00:01:46,920 --> 00:01:51,180
precies 10 keer, Scratch moet bijhouden van elk

35
00:01:51,180 --> 00:01:53,750
uitvoering van de herhaling blok.

36
00:01:53,750 --> 00:01:56,790
Om bij te houden hoe vaak onze lus lichaam is

37
00:01:56,790 --> 00:02:00,360
uitgevoerd, laten zien, maken een variabele genaamd i.

38
00:02:00,360 --> 00:02:03,400
We beginnen i uit bij nul, aangezien onze lus

39
00:02:03,400 --> 00:02:04,650
is nog niet uitgevoerd.

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

41
00:02:10,949 --> 00:02:15,560
Nu zullen we gebruik maken van de tijdens het trefwoord om te beginnen onze lus.

42
00:02:20,100 --> 00:02:24,180
Nu zullen we moeten uitzoeken wanneer onze lus zal stoppen, maar

43
00:02:24,180 --> 00:02:26,730
laten we dit laten voor nu en dan terug te komen om het te.

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

45
00:02:32,150 --> 00:02:35,260
Binnenkant van onze lus, laten we een bericht uit te printen, zoals

46
00:02:35,260 --> 00:02:38,535
"Hi". We kunnen gebruik maken van de printf functie voor dit.

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

48
00:02:49,230 --> 00:02:54,210
Dus nu zullen we constateren dat een iteratie van de lus lichaam heeft

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

50
00:02:55,750 --> 00:03:00,320
We kunnen dat doen door het toevoegen van 1 tot en met, of verhogen, onze teller

51
00:03:00,320 --> 00:03:01,740
variabele i.

52
00:03:01,740 --> 00:03:09,180
Daarvoor kunnen we zeggen i gelijk is aan i plus 1 of meer

53
00:03:09,180 --> 00:03:16,520
gewoon, i plus plus.

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

55
00:03:17,320 --> 00:03:21,810
Dus nu kunnen we zien dat iedere keer onze lus wordt uitgevoerd, onze

56
00:03:21,810 --> 00:03:24,500
teller variabele stijgt met een.

57
00:03:24,500 --> 00:03:29,410
Dus we weten precies hoeveel iteraties we tot nu toe uit te voeren.

58
00:03:29,410 --> 00:03:31,630
Na een herhaling van de lus, onze waarde

59
00:03:31,630 --> 00:03:34,270
i op 1.

60
00:03:34,270 --> 00:03:37,460
Na twee iteraties, zal ik 2.

61
00:03:37,460 --> 00:03:42,640
En na 10 iteraties, zal ik 10.

62
00:03:42,640 --> 00:03:46,780
Dus, als we willen deze lus loopt precies 10 keer, dan

63
00:03:46,780 --> 00:03:49,240
dit is wanneer we willen stoppen.

64
00:03:49,240 --> 00:03:53,860
Dus we willen deze lus draaien terwijl ik minder dan 10, en

65
00:03:53,860 --> 00:03:57,630
dat is precies wat we schrijven, terwijl ik

66
00:03:57,630 --> 00:04:02,450
minder dan 10.

67
00:04:02,450 --> 00:04:06,380
Deze voorwaarde ziet er net als de voorwaarden die wij gebruiken in als

68
00:04:06,380 --> 00:04:07,830
anders blokken.

69
00:04:07,830 --> 00:04:11,690
Nadat het lichaam van onze lus is uitgevoerd, ons programma

70
00:04:11,690 --> 00:04:14,690
zal terug te springen naar de lussen conditie.

71
00:04:14,690 --> 00:04:17,290
Als de conditie waar is, dan is het lichaam van de

72
00:04:17,290 --> 00:04:18,990
lus zal opnieuw worden uitgevoerd.

73
00:04:18,990 --> 00:04:22,190
Als de conditie niet meer het geval, dan is onze lus zal niet

74
00:04:22,190 --> 00:04:25,700
lopen meer en zal doorgaan naar de volgende regel code

75
00:04:25,700 --> 00:04:27,876
onder onze lus.

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

77
00:04:28,550 --> 00:04:30,740
Dus laten we eens een kijkje nemen op een tweede type

78
00:04:30,740 --> 00:04:33,000
lus, de lus.

79
00:04:33,000 --> 00:04:37,310
Naast de tijdens het trefwoord, tussen haakjes, hadden we een ding,

80
00:04:37,310 --> 00:04:39,840
voorwaarde dat nodig waar de

81
00:04:39,840 --> 00:04:42,010
lus worden uitgevoerd.

82
00:04:42,010 --> 00:04:45,440
Dat betekent dat we onze counter variabele te creëren buiten

83
00:04:45,440 --> 00:04:48,760
van de lus en vergeet niet om deze te verhogen op een bepaald punt

84
00:04:48,760 --> 00:04:51,050
binnenzijde van de lus.

85
00:04:51,050 --> 00:04:54,320
De header van onze lus, daarentegen, heeft drie

86
00:04:54,320 --> 00:04:58,510
delen, die elk worden gescheiden door een puntkomma.

87
00:04:58,510 --> 00:05:01,950
In ons eerste derde, kunnen we melding van al hun balie of helper

88
00:05:01,950 --> 00:05:05,000
variabelen willen we gebruiken in onze kring.

89
00:05:05,000 --> 00:05:07,350
In de praktijk kan dit echt nuttig.

90
00:05:07,350 --> 00:05:10,590
We hebben echt die variabele, i, niet nodig na onze terwijl

91
00:05:10,590 --> 00:05:13,650
lus is uitgevoerd, dus we moeten echt niet te verklaren

92
00:05:13,650 --> 00:05:15,810
buiten de lus.

93
00:05:15,810 --> 00:05:19,080
Het tweede derde zal de voorwaarde dat moet worden waar

94
00:05:19,080 --> 00:05:21,850
voor het lichaam opnieuw te worden uitgevoerd, zoals

95
00:05:21,850 --> 00:05:23,330
in onze while-lus.

96
00:05:23,330 --> 00:05:26,350
In onze laatste derde deel, kunnen wij een verklaring dat zal worden

97
00:05:26,350 --> 00:05:30,270
uitgevoerd na elke iteratie van de lus, zodat we niet hebben

98
00:05:30,270 --> 00:05:32,710
om het in te bouwen in de lus.

99
00:05:32,710 --> 00:05:38,390
Dus laten we een schrijven voor lus die naar beneden telt vanaf 5 tot 1.

100
00:05:38,390 --> 00:05:41,790
We beginnen met de voor zoekwoord.

101
00:05:41,790 --> 00:05:44,680
We kunnen een teller variabele eerste, die we zullen

102
00:05:44,680 --> 00:05:47,840
ingesteld op 5 dit keer aangezien we aftellen,

103
00:05:47,840 --> 00:05:50,110
gevolgd door een puntkomma.

104
00:05:50,110 --> 00:05:53,660
Volgende is onze toestand, die we zullen terug te komen.

105
00:05:53,660 --> 00:05:57,540
Ten derde willen we onze counter variabele te verlagen na

106
00:05:57,540 --> 00:05:59,620
elke iteratie van de lus.

107
00:05:59,620 --> 00:06:04,740
Dus in plaats van te zeggen dat ik plus plus, zullen we zeggen dat ik min min.

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

109
00:06:05,300 --> 00:06:09,490
Dus we willen dat de lus te lopen terwijl ik nog

110
00:06:09,490 --> 00:06:11,960
groter dan 0.

111
00:06:11,960 --> 00:06:16,160
In het lichaam van de lus, laten we afdrukken van de waarde van i.

112
00:06:16,160 --> 00:06:20,480
Om dit te doen, zullen we gebruik maken van de printf functie, met behulp van de% d

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

114
00:06:21,650 --> 00:06:24,820
Denk er aan dat tijdelijke aanduiding vervangen door de

115
00:06:24,820 --> 00:06:27,040
waarde van i.

116
00:06:27,040 --> 00:06:32,060
Tot slot voegen we een verklaring na onze for-lus.

117
00:06:32,060 --> 00:06:35,850
Wanneer we deze lus lopen, zal ik beginnen bij 5,

118
00:06:35,850 --> 00:06:38,070
zo 5 zal worden afgedrukt.

119
00:06:38,070 --> 00:06:42,000
Zodra ik krijgt op 0, de voortzetting conditie, i

120
00:06:42,000 --> 00:06:44,450
groter dan 0, zal niet langer vasthouden.

121
00:06:44,450 --> 00:06:47,330
Dus onze lus stopt de uitvoering, en we zullen zien de

122
00:06:47,330 --> 00:06:49,850
verklaring na de lus.

123
00:06:49,850 --> 00:06:51,340
Dus laten we deze code uitvoert.

124
00:06:51,340 --> 00:06:52,700
Eerst zullen we de samenstelling van een

125
00:06:52,700 --> 00:06:56,460
countdown.c met make aftellen.

126
00:06:56,460 --> 00:06:59,320
Nu kunnen we deze code uitvoeren met. / Countdown.

127
00:07:02,340 --> 00:07:06,040
In beide while loops en voor loops, onze voortzetting

128
00:07:06,040 --> 00:07:09,010
voorwaarde zal gecontroleerd worden alvorens het lichaam

129
00:07:09,010 --> 00:07:10,960
de lus wordt uitgevoerd.

130
00:07:10,960 --> 00:07:13,840
Dat betekent dat als onze voorwaarde niet aanvankelijk

131
00:07:13,840 --> 00:07:18,100
waar is, dan is het lichaam van onze lus zal nooit worden uitgevoerd.

132
00:07:18,100 --> 00:07:22,060
Dus het is soms handig om de conditie te controleren na de

133
00:07:22,060 --> 00:07:25,150
body van de lus dan daarvoor.

134
00:07:25,150 --> 00:07:28,270
Dus laten we schrijven een lus aan de gebruiker om een ​​aantal vragen

135
00:07:28,270 --> 00:07:30,990
tot een positief getal wordt toegevoerd.

136
00:07:30,990 --> 00:07:34,740
Als de gebruiker een negatief getal is, dan willen we hen te vragen

137
00:07:34,740 --> 00:07:36,260
voor een ander nummer.

138
00:07:36,260 --> 00:07:38,940
Dus we willen deze prompt te worden binnen de

139
00:07:38,940 --> 00:07:41,050
lichaam van de lus.

140
00:07:41,050 --> 00:07:44,730
Echter, wanneer de lus wordt uitgevoerd voor de eerste keer de gebruiker

141
00:07:44,730 --> 00:07:46,750
heeft ons niet gegeven een aantal nog niet.

142
00:07:46,750 --> 00:07:49,640
Dus het heeft geen zin om te controleren of het positief.

143
00:07:49,640 --> 00:07:54,020
In plaats daarvan zullen we het nummer wilt controleren nadat het lichaam van

144
00:07:54,020 --> 00:07:55,720
de lus wordt uitgevoerd.

145
00:07:55,720 --> 00:08:00,310
We kunnen dit doen met een doe while lus.

146
00:08:00,310 --> 00:08:03,560
Eerst maken we een variabele, n, dat zal houden

147
00:08:03,560 --> 00:08:05,230
invoer van de gebruiker.

148
00:08:05,230 --> 00:08:09,960
Nu gebruiken we de do trefwoord, gevolgd door accolades die

149
00:08:09,960 --> 00:08:12,930
zal beginnen het lichaam van onze lus.

150
00:08:12,930 --> 00:08:16,230
In het lichaam, kunnen we de gebruiker vragen om een ​​aantal met de

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

152
00:08:18,480 --> 00:08:23,230
Nu, we willen het lichaam van deze lus om opnieuw uit te voeren als

153
00:08:23,230 --> 00:08:28,370
de gebruiker heeft ingevoerd een negatief getal, dus we zullen zeggen, terwijl n

154
00:08:28,370 --> 00:08:30,420
kleiner is dan 0.

155
00:08:30,420 --> 00:08:33,140
Hier zie je de puntkomma na de while-opdracht.

156
00:08:38,909 --> 00:08:40,679
Dus laten we deze code uitvoert.

157
00:08:40,679 --> 00:08:44,780
Eerst zullen we compileren dit met make positief.

158
00:08:44,780 --> 00:08:49,340
Nu kunnen we het programma met. / Positief.

159
00:08:49,340 --> 00:08:52,660
Als we dit programma een negatief getal, zoals negatieve

160
00:08:52,660 --> 00:08:56,560
4, dan zullen we weer gevraagd worden om een ​​aantal sinds de

161
00:08:56,560 --> 00:09:00,490
toestand van onze doe while lus waar was.

162
00:09:00,490 --> 00:09:04,690
Nadat we een positief getal, als 8, dan

163
00:09:04,690 --> 00:09:08,560
toestand van onze do while loop niet langer waar.

164
00:09:08,560 --> 00:09:12,080
Dus de lus wordt niet opnieuw uitgevoerd.

165
00:09:12,080 --> 00:09:15,290
En dat is het voor de drie soorten loops gebruiken we in C.

166
00:09:15,290 --> 00:09:18,840
Mijn naam is Tommy, en dit is CS50.