1
00:00:07,370 --> 00:00:09,760
[Powered by Google Translate] TOMMY MACWILLIAM: Să vorbim despre bucle, una din comun

2
00:00:09,760 --> 00:00:13,380
de programare construiește vom vedea pe parcursul CS50.

3
00:00:13,380 --> 00:00:15,570
Vom folosi bucle atunci când doriți să efectuați o

4
00:00:15,570 --> 00:00:17,200
sarcină mai mult de o dată.

5
00:00:17,200 --> 00:00:20,700
De exemplu, am putea dori pentru a imprima "hi", de 100 de ori sau de imprimare

6
00:00:20,700 --> 00:00:22,700
din toate literele din alfabet.

7
00:00:22,700 --> 00:00:26,030
În ambele cazuri, avem un singur lucru vrem să facem

8
00:00:26,030 --> 00:00:28,700
de mai multe ori, imprima ceva.

9
00:00:28,700 --> 00:00:31,970
Cu toate acestea, ceea ce ne imprima de fiecare data poate varia.

10
00:00:31,970 --> 00:00:34,530
Astfel încât să putem face ceva ușor diferit pe fiecare

11
00:00:34,530 --> 00:00:37,820
iterație, sau a alerga prin intermediul, de bucla.

12
00:00:37,820 --> 00:00:41,280
Vom vedea trei tipuri diferite de bucle în C, în timp ce

13
00:00:41,280 --> 00:00:44,700
bucle, bucle pentru, și în timp ce face bucle.

14
00:00:44,700 --> 00:00:47,850
Deși aceste trei tipuri de bucle au o sintaxă diferită,

15
00:00:47,850 --> 00:00:50,630
ideile din spatele lor sunt aceleași.

16
00:00:50,630 --> 00:00:53,930
Vom defini unele bloc de cod în cadrul acolade,

17
00:00:53,930 --> 00:00:57,810
numit corpul buclei, pe care dorim să fie executat

18
00:00:57,810 --> 00:00:59,790
un numar de ori.

19
00:00:59,790 --> 00:01:03,370
Prin schimbarea valorilor variabilelor folosite în organism, am

20
00:01:03,370 --> 00:01:07,570
poate face bucla nostru facem ceva diferit de fiecare dată când este rulat.

21
00:01:07,570 --> 00:01:10,750
Cu orice bucla ne scrie, vom avea nevoie, de asemenea, să decidă când

22
00:01:10,750 --> 00:01:12,400
bucla se va opri.

23
00:01:12,400 --> 00:01:15,650
Dacă nu facem asta, atunci calculatorul nostru de încredere va continua

24
00:01:15,650 --> 00:01:19,040
pentru a rula ca bucla până când vom ucide programului.

25
00:01:19,040 --> 00:01:22,490
În Scratch, am putea folosi repeta de n ori

26
00:01:22,490 --> 00:01:24,600
bloca pentru a crea o buclă.

27
00:01:24,600 --> 00:01:28,200
Toate piesele din interiorul unui bloc care a spus Repeta de 10

28
00:01:28,200 --> 00:01:30,130
ar fi rulat de 10 ori.

29
00:01:30,130 --> 00:01:34,160
Și apoi, ne-ar trece la piesele după care bucla.

30
00:01:34,160 --> 00:01:38,140
Deci, starea noastră oprire a fost pur și simplu, acest bloc a fost

31
00:01:38,140 --> 00:01:39,830
a alerga de 10 ori.

32
00:01:39,830 --> 00:01:43,900
Deci, haideți să recreeze acest lucru în C. Pentru a se asigura Scratch

33
00:01:43,900 --> 00:01:46,920
că piesele din cadrul blocului repetare sunt executate

34
00:01:46,920 --> 00:01:51,180
exact 10 de ori, Scratch trebuie să țină evidența fiecărei

35
00:01:51,180 --> 00:01:53,750
executarea blocului repeta.

36
00:01:53,750 --> 00:01:56,790
Pentru a ține evidența de câte ori organismul nostru bucla a fost

37
00:01:56,790 --> 00:02:00,360
executat, să creați o variabilă numită i.

38
00:02:00,360 --> 00:02:03,400
Vom începe i de la zero, deoarece bucla nostru

39
00:02:03,400 --> 00:02:04,650
nu a fost încă executați.

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

41
00:02:10,949 --> 00:02:15,560
Acum vom folosi cuvântul cheie în timp ce pentru a începe bucla nostru.

42
00:02:20,100 --> 00:02:24,180
Acum, vom avea nevoie să ne dăm seama când bucla noastră se va opri, dar

43
00:02:24,180 --> 00:02:26,730
să-i lăsăm asta pentru acum și apoi te întorci la ea.

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

45
00:02:32,150 --> 00:02:35,260
In interiorul buclei noastre, să imprimați doar un mesaj de afară, cum ar fi

46
00:02:35,260 --> 00:02:38,535
"Hi". Putem folosi funcția printf pentru acest lucru.

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

48
00:02:49,230 --> 00:02:54,210
Deci, acum, vom înregistra ca o repetare a corpului buclă are

49
00:02:54,210 --> 00:02:55,750
a fost executat.

50
00:02:55,750 --> 00:03:00,320
Putem face asta prin adăugarea de la 1 la, sau incrementare, contra noastră

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

52
00:03:01,740 --> 00:03:09,180
Pentru a face acest lucru, putem spune i este egal cu I, plus 1, sau mai mult

53
00:03:09,180 --> 00:03:16,520
pur si simplu, am plus plus.

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

55
00:03:17,320 --> 00:03:21,810
Deci, acum putem vedea că de fiecare dată când se execută bucla nostru, noastră

56
00:03:21,810 --> 00:03:24,500
variabila contor merge de unul.

57
00:03:24,500 --> 00:03:29,410
Deci, noi știm exact câte iterații am fugi până acum.

58
00:03:29,410 --> 00:03:31,630
După o iterație a buclei, valoarea noastră

59
00:03:31,630 --> 00:03:34,270
de i va fi de 1.

60
00:03:34,270 --> 00:03:37,460
După două iterații, i va fi 2.

61
00:03:37,460 --> 00:03:42,640
Și, după 10 iterații, i va fi de 10.

62
00:03:42,640 --> 00:03:46,780
Deci, dacă ne dorim să rulați această buclă exact 10 de ori, apoi

63
00:03:46,780 --> 00:03:49,240
acest lucru este atunci când vrem să se oprească.

64
00:03:49,240 --> 00:03:53,860
Așa că vrem să rulați acest buclă în timp ce i este mai mic de 10, și

65
00:03:53,860 --> 00:03:57,630
asta e exact ceea ce vom scrie, în timp ce eu

66
00:03:57,630 --> 00:04:02,450
este mai mic de 10.

67
00:04:02,450 --> 00:04:06,380
Această condiție arata la fel ca și condițiile le-am folosit în cazul în care

68
00:04:06,380 --> 00:04:07,830
Blocuri altceva.

69
00:04:07,830 --> 00:04:11,690
După corpul buclei nostru a fost executat, programul nostru

70
00:04:11,690 --> 00:04:14,690
va sări înapoi până la starea bucle.

71
00:04:14,690 --> 00:04:17,290
În cazul în care condiția este adevărată, atunci corpul

72
00:04:17,290 --> 00:04:18,990
buclă va fi rulat din nou.

73
00:04:18,990 --> 00:04:22,190
În cazul în care condiția nu mai este adevărată, atunci bucla nostru nu va fi

74
00:04:22,190 --> 00:04:25,700
alerga mai și se va trece la următoarea linie de cod

75
00:04:25,700 --> 00:04:27,876
sub bucla nostru.

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

77
00:04:28,550 --> 00:04:30,740
Deci, haideți să aruncăm o privire la un al doilea tip de

78
00:04:30,740 --> 00:04:33,000
buclă, pentru bucla.

79
00:04:33,000 --> 00:04:37,310
De lângă cuvântul cheie în timp ce, în paranteze, am avut un singur lucru,

80
00:04:37,310 --> 00:04:39,840
condiția ca să fie adevărat necesară pentru

81
00:04:39,840 --> 00:04:42,010
corpul buclei pentru a fi rulat.

82
00:04:42,010 --> 00:04:45,440
Asta înseamnă că am avut de a crea variabila noastră contra afara

83
00:04:45,440 --> 00:04:48,760
de buclă și amintiți-vă să-l incrementa la un moment dat

84
00:04:48,760 --> 00:04:51,050
interiorul buclei.

85
00:04:51,050 --> 00:04:54,320
Antet de nostru pentru bucla, pe de altă parte, are trei

86
00:04:54,320 --> 00:04:58,510
părți, fiecare dintre care vor fi separate cu punct și virgulă.

87
00:04:58,510 --> 00:05:01,950
În prima noastră treilea, putem declara orice ghișeu sau helper

88
00:05:01,950 --> 00:05:05,000
variabile am dori să le folosească în buclă nostru.

89
00:05:05,000 --> 00:05:07,350
În practică, acest lucru poate fi foarte util.

90
00:05:07,350 --> 00:05:10,590
Noi chiar nu au nevoie de acea variabilă, i, după un timp ne

91
00:05:10,590 --> 00:05:13,650
bucla a alerga, așa că într-adevăr nu ar trebui să-l declare

92
00:05:13,650 --> 00:05:15,810
în afara buclei.

93
00:05:15,810 --> 00:05:19,080
Cea de a treia a doua va fi condiție care trebuie să fie adevărat

94
00:05:19,080 --> 00:05:21,850
pentru ca organismul să fie executată din nou, la fel ca

95
00:05:21,850 --> 00:05:23,330
în buclă în timp ce noastre.

96
00:05:23,330 --> 00:05:26,350
În ultimul nostru treilea, putem rula o declarație care va fi

97
00:05:26,350 --> 00:05:30,270
executat după fiecare iterație a buclei, deci nu avem

98
00:05:30,270 --> 00:05:32,710
să-l construiască în corpul buclei.

99
00:05:32,710 --> 00:05:38,390
Deci, haideți să scrie o buclă pentru care contează jos de la 5 la 1.

100
00:05:38,390 --> 00:05:41,790
Vom începe cu cuvântul cheie pentru.

101
00:05:41,790 --> 00:05:44,680
Putem crea o variabila contor în primul rând, pe care le vom

102
00:05:44,680 --> 00:05:47,840
setat la 5 de data asta, deoarece suntem de numărare în jos,

103
00:05:47,840 --> 00:05:50,110
urmat de un punct și virgulă.

104
00:05:50,110 --> 00:05:53,660
Următorul este starea noastră, pe care ne vom întoarce la.

105
00:05:53,660 --> 00:05:57,540
În al treilea rând, am dori să ne decrementeze variabila contor, după

106
00:05:57,540 --> 00:05:59,620
fiecare iterație a buclei.

107
00:05:59,620 --> 00:06:04,740
Deci, mai degrabă decât să spui că, plus, plus, vom spune că minus minus.

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

109
00:06:05,300 --> 00:06:09,490
Deci, vrem corpul buclei pentru a rula în timp ce i este încă

110
00:06:09,490 --> 00:06:11,960
mai mare decât 0.

111
00:06:11,960 --> 00:06:16,160
În corpul buclei, să imprimați valoarea lui i.

112
00:06:16,160 --> 00:06:20,480
Pentru a face acest lucru, vom utiliza funcția printf, folosind% d

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

114
00:06:21,650 --> 00:06:24,820
Amintiți-vă, că substituent vor fi înlocuite cu

115
00:06:24,820 --> 00:06:27,040
valoarea lui i.

116
00:06:27,040 --> 00:06:32,060
În cele din urmă, să adauge o declarație, după nostru de buclă.

117
00:06:32,060 --> 00:06:35,850
Când vom rula aceasta bucla, i se va incepe de la 5,

118
00:06:35,850 --> 00:06:38,070
deci 5 va fi imprimat.

119
00:06:38,070 --> 00:06:42,000
După ce am ajunge la 0, condiție continuarea, i este

120
00:06:42,000 --> 00:06:44,450
mai mare decât 0, nu va mai ține.

121
00:06:44,450 --> 00:06:47,330
Deci bucla nostru va opri de executare, și vom vedea

122
00:06:47,330 --> 00:06:49,850
declarație după bucla.

123
00:06:49,850 --> 00:06:51,340
Așa că hai să executați acest cod.

124
00:06:51,340 --> 00:06:52,700
În primul rând, vom compila un

125
00:06:52,700 --> 00:06:56,460
countdown.c cu marca numărătoarea inversă.

126
00:06:56,460 --> 00:06:59,320
Acum, putem rula acest cod cu / numărătoarea inversă..

127
00:07:02,340 --> 00:07:06,040
În ambele bucle timp și pentru bucle, ne continuarea

128
00:07:06,040 --> 00:07:09,010
condiție va fi verificată înainte de organism

129
00:07:09,010 --> 00:07:10,960
a bucla este executat.

130
00:07:10,960 --> 00:07:13,840
Asta înseamnă că, în cazul în care starea noastră nu este inițial

131
00:07:13,840 --> 00:07:18,100
adevărat, atunci corpul buclei nostru nu va fi rulat.

132
00:07:18,100 --> 00:07:22,060
Deci, este uneori utilă pentru a verifica starea după

133
00:07:22,060 --> 00:07:25,150
corpul buclei, mai degrabă decât înainte.

134
00:07:25,150 --> 00:07:28,270
Deci, haideți să scrie o buclă pentru a solicita utilizatorului pentru un număr de

135
00:07:28,270 --> 00:07:30,990
până la un număr pozitiv este furnizat.

136
00:07:30,990 --> 00:07:34,740
Dacă utilizatorul introduce un număr negativ, vom dori să-i întreb

137
00:07:34,740 --> 00:07:36,260
pentru un alt număr.

138
00:07:36,260 --> 00:07:38,940
Așa că veți dori acest prompt să fie în interiorul

139
00:07:38,940 --> 00:07:41,050
Organismul de pe bucla.

140
00:07:41,050 --> 00:07:44,730
Cu toate acestea, atunci când bucla se execută pentru prima dată, utilizatorul

141
00:07:44,730 --> 00:07:46,750
nu a dat încă ne numărul.

142
00:07:46,750 --> 00:07:49,640
Deci nu are sens pentru a verifica dacă acesta este pozitiv.

143
00:07:49,640 --> 00:07:54,020
În schimb, vom dori să verificați numărul de după corpul

144
00:07:54,020 --> 00:07:55,720
bucla se execută.

145
00:07:55,720 --> 00:08:00,310
Putem face acest lucru cu un do while.

146
00:08:00,310 --> 00:08:03,560
În primul rând, vom crea o variabila, n, care va deține

147
00:08:03,560 --> 00:08:05,230
utilizatorului de intrare.

148
00:08:05,230 --> 00:08:09,960
Acum, vom folosi cuvântul cheie do, urmată de acoladele care

149
00:08:09,960 --> 00:08:12,930
va începe corpul buclei nostru.

150
00:08:12,930 --> 00:08:16,230
În organism, putem solicita utilizatorul pentru un număr cu

151
00:08:16,230 --> 00:08:18,480
GetInt funcție.

152
00:08:18,480 --> 00:08:23,230
Acum, ne vom dori corpul această buclă de a executa din nou în cazul în care

153
00:08:23,230 --> 00:08:28,370
utilizatorul tastat un număr negativ, deci vom spune în timp ce n

154
00:08:28,370 --> 00:08:30,420
este mai mică decât 0.

155
00:08:30,420 --> 00:08:33,140
Observați punct și virgulă aici după declarația timp.

156
00:08:38,909 --> 00:08:40,679
Așa că hai să executați acest cod.

157
00:08:40,679 --> 00:08:44,780
În primul rând, vom compila acest lucru cu a face pozitiv.

158
00:08:44,780 --> 00:08:49,340
Acum putem rula programul cu. / Pozitiv.

159
00:08:49,340 --> 00:08:52,660
Dacă vom da acest program un număr negativ, cum ar fi negativ

160
00:08:52,660 --> 00:08:56,560
4, atunci vom solicita din nou pentru un număr de la

161
00:08:56,560 --> 00:09:00,490
condiție a face noastre în timp ce bucla era adevărat.

162
00:09:00,490 --> 00:09:04,690
După ce vom da un număr pozitiv, cum ar fi 8, apoi

163
00:09:04,690 --> 00:09:08,560
condiție a face noastre în timp ce bucla nu va mai fi valabil.

164
00:09:08,560 --> 00:09:12,080
Deci bucla nu va fi executat din nou.

165
00:09:12,080 --> 00:09:15,290
Și asta e tot pentru cele trei tipuri de bucle vom folosi în C.

166
00:09:15,290 --> 00:09:18,840
Numele meu este Tommy, iar acest lucru este CS50.