1
00:00:07,370 --> 00:00:09,760
[Powered by Google Translate] TOMMY MacWilliam: Parlem de bucles, un dels comuns

2
00:00:09,760 --> 00:00:13,380
construccions de programació que veurem al llarg CS50.

3
00:00:13,380 --> 00:00:15,570
Utilitzarem els bucles quan es vol fer una

4
00:00:15,570 --> 00:00:17,200
tasca més d'una vegada.

5
00:00:17,200 --> 00:00:20,700
Per exemple, podríem voler imprimir "Hola" 100 vegades o impressió

6
00:00:20,700 --> 00:00:22,700
totes les lletres de l'alfabet.

7
00:00:22,700 --> 00:00:26,030
En ambdós casos, tenim una cosa que volem fer

8
00:00:26,030 --> 00:00:28,700
diverses vegades, imprimir alguna cosa.

9
00:00:28,700 --> 00:00:31,970
No obstant això, el que imprimeix cada vegada que pot variar.

10
00:00:31,970 --> 00:00:34,530
Així que podem fer alguna cosa una mica diferent en cada

11
00:00:34,530 --> 00:00:37,820
iteració, o executar a través, del bucle.

12
00:00:37,820 --> 00:00:41,280
Anem a veure tres tipus de bucles en C, mentre que

13
00:00:41,280 --> 00:00:44,700
bucles, els bucles for, while i fer.

14
00:00:44,700 --> 00:00:47,850
Tot i que aquests tres tipus de bucles té una sintaxi diferent,

15
00:00:47,850 --> 00:00:50,630
les idees darrere d'ells són els mateixos.

16
00:00:50,630 --> 00:00:53,930
Definirem algun bloc de codi entre claus,

17
00:00:53,930 --> 00:00:57,810
anomenat el cos del bucle, que volem ser executat

18
00:00:57,810 --> 00:00:59,790
cert nombre de vegades.

19
00:00:59,790 --> 00:01:03,370
En canviar els valors de les variables usades en el cos, es

20
00:01:03,370 --> 00:01:07,570
pot fer que el nostre llaç de fer alguna cosa diferent cada vegada que s'executi.

21
00:01:07,570 --> 00:01:10,750
Amb un bucle que escrivim, també haurà de decidir quan és el

22
00:01:10,750 --> 00:01:12,400
bucle s'aturarà.

23
00:01:12,400 --> 00:01:15,650
Si no fem això, llavors el nostre equip seguirà fidel

24
00:01:15,650 --> 00:01:19,040
per executar aquest bucle fins que matem al programa.

25
00:01:19,040 --> 00:01:22,490
En Scratch, podríem utilitzar la repetició de n vegades

26
00:01:22,490 --> 00:01:24,600
bloquejar per crear un bucle.

27
00:01:24,600 --> 00:01:28,200
Totes les peces dins d'un bloc que va dir repetició 10

28
00:01:28,200 --> 00:01:30,130
s'executi 10 vegades.

29
00:01:30,130 --> 00:01:34,160
I després, ens agradaria passar a les peces després d'aquest bucle.

30
00:01:34,160 --> 00:01:38,140
Així que la nostra condició de detenció va ser simplement, aquest bloc ha estat

31
00:01:38,140 --> 00:01:39,830
executar 10 vegades.

32
00:01:39,830 --> 00:01:43,900
Així que anem a recrear això en C. Per tal de garantir a les ratllades

33
00:01:43,900 --> 00:01:46,920
que les peces dins del bloc de repetició s'executen

34
00:01:46,920 --> 00:01:51,180
exactament 10 vegades, Scratch necessita per realitzar un seguiment de cada

35
00:01:51,180 --> 00:01:53,750
execució del bloc de repetició.

36
00:01:53,750 --> 00:01:56,790
Per portar el compte de les vegades que el nostre cos del bucle estat

37
00:01:56,790 --> 00:02:00,360
executat, crearem una variable anomenada i.

38
00:02:00,360 --> 00:02:03,400
Anem a començar ia zero, ja que el nostre bucle

39
00:02:03,400 --> 00:02:04,650
no ha estat executat encara.

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

41
00:02:10,949 --> 00:02:15,560
Ara utilitzarem la paraula clau, mentre que per a començar el nostre bucle.

42
00:02:20,100 --> 00:02:24,180
Ara haurem d'esbrinar quan el nostre bucle s'aturarà, però

43
00:02:24,180 --> 00:02:26,730
deixem això per ara i després tornar-hi.

44
00:02:30,970 --> 00:02:32,150
Està bé.

45
00:02:32,150 --> 00:02:35,260
Dins del nostre circuit, anem a imprimir un missatge, com

46
00:02:35,260 --> 00:02:38,535
"Hi". Podem utilitzar la funció printf per això.

47
00:02:48,400 --> 00:02:49,230
Està bé.

48
00:02:49,230 --> 00:02:54,210
Així que ara anem a registrar que una iteració del cos del cicle ha

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

50
00:02:55,750 --> 00:03:00,320
Podem fer-ho mitjançant l'addició d'1 a, o incrementar, el nostre comptador

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

52
00:03:01,740 --> 00:03:09,180
Per això, podem dir que és igual a i + 1, o més

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

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

55
00:03:17,320 --> 00:03:21,810
Així que ara podem veure que cada vegada que el nostre bucle s'executa, el nostre

56
00:03:21,810 --> 00:03:24,500
variable comptador s'incrementa en un.

57
00:03:24,500 --> 00:03:29,410
Així que sabem exactament quantes iteracions ens hem quedat fins ara.

58
00:03:29,410 --> 00:03:31,630
Després d'una iteració del bucle, el nostre valor

59
00:03:31,630 --> 00:03:34,270
de i serà 1.

60
00:03:34,270 --> 00:03:37,460
Després de dues iteracions, seré 2.

61
00:03:37,460 --> 00:03:42,640
I després de 10 iteracions, seré 10.

62
00:03:42,640 --> 00:03:46,780
Així que, si volem executar aquest bucle exactament 10 vegades, i després

63
00:03:46,780 --> 00:03:49,240
això és quan volem aturar.

64
00:03:49,240 --> 00:03:53,860
Així que volem executar aquest bucle while i és menor que 10, i

65
00:03:53,860 --> 00:03:57,630
això és exactament el que anem a escriure, mentre que i

66
00:03:57,630 --> 00:04:02,450
és inferior a 10.

67
00:04:02,450 --> 00:04:06,380
Aquesta condició s'assembla a les condicions que hem utilitzat en cas d'

68
00:04:06,380 --> 00:04:07,830
blocs cosa.

69
00:04:07,830 --> 00:04:11,690
Després que el cos del nostre bucle ha estat executat, el programa de

70
00:04:11,690 --> 00:04:14,690
torni a saltar a la condició de bucles.

71
00:04:14,690 --> 00:04:17,290
Si la condició és veritable, llavors el cos de la

72
00:04:17,290 --> 00:04:18,990
bucle s'executa de nou.

73
00:04:18,990 --> 00:04:22,190
Si la condició ja no és així, llavors el nostre llaç no serà

74
00:04:22,190 --> 00:04:25,700
córrer més i passarà a la següent línia de codi

75
00:04:25,700 --> 00:04:27,876
sota del nostre bucle.

76
00:04:27,876 --> 00:04:28,550
Està bé.

77
00:04:28,550 --> 00:04:30,740
Així que donem una ullada a un segon tipus de

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

79
00:04:33,000 --> 00:04:37,310
Al costat de la paraula clau, mentre que, entre parèntesi, teníem una cosa,

80
00:04:37,310 --> 00:04:39,840
la condició que sigui necessari per ser veritat per a la

81
00:04:39,840 --> 00:04:42,010
cos del bucle s'executarà.

82
00:04:42,010 --> 00:04:45,440
Això vol dir que vam haver crear la nostra variable de comptador extern

83
00:04:45,440 --> 00:04:48,760
del bucle i s'acorda d'incrementar en algun moment

84
00:04:48,760 --> 00:04:51,050
a l'interior del bucle.

85
00:04:51,050 --> 00:04:54,320
La capçalera del nostre bucle for, d'altra banda, té tres

86
00:04:54,320 --> 00:04:58,510
parts, cadascuna de les quals es separen amb un punt i coma.

87
00:04:58,510 --> 00:05:01,950
En el nostre primer terç, podem declarar qualsevol comptador o auxiliar

88
00:05:01,950 --> 00:05:05,000
variables per utilitzar el nostre bucle.

89
00:05:05,000 --> 00:05:07,350
A la pràctica, això pot ser molt útil.

90
00:05:07,350 --> 00:05:10,590
Realment no necessito aquesta variable, i, després del nostre temps

91
00:05:10,590 --> 00:05:13,650
bucle s'executa, així que realment no hauria de tenir de declarar

92
00:05:13,650 --> 00:05:15,810
fora del bucle.

93
00:05:15,810 --> 00:05:19,080
El segon terç serà la condició que s'ha de complir

94
00:05:19,080 --> 00:05:21,850
perquè el cos s'executa de nou, igual

95
00:05:21,850 --> 00:05:23,330
en el nostre bucle while.

96
00:05:23,330 --> 00:05:26,350
En el nostre últim terç, es pot executar una instrucció que serà

97
00:05:26,350 --> 00:05:30,270
executat després de cada iteració del bucle, de manera que no tenen

98
00:05:30,270 --> 00:05:32,710
per construir en el cos del bucle.

99
00:05:32,710 --> 00:05:38,390
Així que anem a escriure un bucle for que un compte enrere de 5 a 1.

100
00:05:38,390 --> 00:05:41,790
Anem a començar amb la paraula clau per.

101
00:05:41,790 --> 00:05:44,680
Podem crear una variable de comptador en primer lloc, que anem a

102
00:05:44,680 --> 00:05:47,840
s'estableix en 5 aquesta vegada ja que estem comptant,

103
00:05:47,840 --> 00:05:50,110
seguit d'un punt i coma.

104
00:05:50,110 --> 00:05:53,660
El següent és la nostra condició, que tornarem.

105
00:05:53,660 --> 00:05:57,540
En tercer lloc, ens agradaria disminuir la nostra variable comptador després

106
00:05:57,540 --> 00:05:59,620
cada iteració del bucle.

107
00:05:59,620 --> 00:06:04,740
Així que en lloc de dir i plus plus, direm que em minus minus.

108
00:06:04,740 --> 00:06:05,300
Està bé.

109
00:06:05,300 --> 00:06:09,490
Així que volem que el cos del bucle s'executi mentre jo encara

110
00:06:09,490 --> 00:06:11,960
major que 0.

111
00:06:11,960 --> 00:06:16,160
En el cos del bucle, anem a imprimir el valor de i.

112
00:06:16,160 --> 00:06:20,480
Per això, utilitzarem la funció printf, amb el% d

113
00:06:20,480 --> 00:06:21,650
marcador de posició.

114
00:06:21,650 --> 00:06:24,820
Recordeu que la variable que serà reemplaçada per la

115
00:06:24,820 --> 00:06:27,040
valor de i.

116
00:06:27,040 --> 00:06:32,060
Finalment, anem a afegir una declaració després del nostre bucle for.

117
00:06:32,060 --> 00:06:35,850
Quan s'executa aquest bucle, vaig a començar als 5,

118
00:06:35,850 --> 00:06:38,070
així que 5 s'imprimirà.

119
00:06:38,070 --> 00:06:42,000
Quan arriba a 0, la condició de continuïtat, i és

120
00:06:42,000 --> 00:06:44,450
més gran que 0, ja no tindrà.

121
00:06:44,450 --> 00:06:47,330
Així que el nostre bucle s'aturarà l'execució, i anem a veure el

122
00:06:47,330 --> 00:06:49,850
declaració després del bucle.

123
00:06:49,850 --> 00:06:51,340
Així que anem a executar aquest codi.

124
00:06:51,340 --> 00:06:52,700
En primer lloc, anem a elaborar un

125
00:06:52,700 --> 00:06:56,460
countdown.c amb fer de compte enrere.

126
00:06:56,460 --> 00:06:59,320
Ara, podem executar aquest codi amb. / Compte enrere.

127
00:07:02,340 --> 00:07:06,040
En ambdós bucles while i for loops, la nostra continuació

128
00:07:06,040 --> 00:07:09,010
se li ha d'examinar abans que el cos

129
00:07:09,010 --> 00:07:10,960
del bucle s'executa.

130
00:07:10,960 --> 00:07:13,840
Això vol dir que, si la nostra condició no és inicialment

131
00:07:13,840 --> 00:07:18,100
cert, llavors el cos del nostre bucle mai s'executarà.

132
00:07:18,100 --> 00:07:22,060
Així que de vegades és útil per verificar l'estat després de la

133
00:07:22,060 --> 00:07:25,150
cos del bucle en lloc d'abans d'ell.

134
00:07:25,150 --> 00:07:28,270
Així que anem a escriure un bucle per sol · licitar a l'usuari un nombre

135
00:07:28,270 --> 00:07:30,990
fins que un nombre positiu es subministra.

136
00:07:30,990 --> 00:07:34,740
Si l'usuari introdueix un nombre negatiu, anem a demanar-los

137
00:07:34,740 --> 00:07:36,260
per un altre número.

138
00:07:36,260 --> 00:07:38,940
Així que anem a voler aquest missatge per estar dins de la

139
00:07:38,940 --> 00:07:41,050
cos fora del bucle.

140
00:07:41,050 --> 00:07:44,730
No obstant això, quan el bucle s'executa per primera vegada, l'usuari

141
00:07:44,730 --> 00:07:46,750
no ens ha donat el nombre encara.

142
00:07:46,750 --> 00:07:49,640
Així que no té sentit per comprovar si és positiu.

143
00:07:49,640 --> 00:07:54,020
En el seu lloc, anem a voler comprovar el nombre que segueix al cos de

144
00:07:54,020 --> 00:07:55,720
el bucle s'executa.

145
00:07:55,720 --> 00:08:00,310
Podem fer això amb un bucle Do While.

146
00:08:00,310 --> 00:08:03,560
En primer lloc, crearem una variable, n, que contindrà

147
00:08:03,560 --> 00:08:05,230
l'usuari d'entrada.

148
00:08:05,230 --> 00:08:09,960
Ara utilitzarem la paraula clau do, seguit de claus que

149
00:08:09,960 --> 00:08:12,930
començarà el cos del nostre bucle.

150
00:08:12,930 --> 00:08:16,230
En el cos, es pot sol · licitar a l'usuari un número amb el

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

152
00:08:18,480 --> 00:08:23,230
Ara, anem a voler el cos d'aquest bucle s'execute altra vegada si

153
00:08:23,230 --> 00:08:28,370
l'usuari va escriure un nombre negatiu, de manera que anem a dir mentre que n

154
00:08:28,370 --> 00:08:30,420
és menor que 0.

155
00:08:30,420 --> 00:08:33,140
Observeu el punt i coma aquí després de la sentència while.

156
00:08:38,909 --> 00:08:40,679
Així que anem a executar aquest codi.

157
00:08:40,679 --> 00:08:44,780
En primer lloc, farem amb això compilar positiu.

158
00:08:44,780 --> 00:08:49,340
Ara podem executar el programa amb. / Positiu.

159
00:08:49,340 --> 00:08:52,660
Si donem a aquest programa un nombre negatiu, com negatiu

160
00:08:52,660 --> 00:08:56,560
4, llavors ens demanarà de nou per un nombre des de la

161
00:08:56,560 --> 00:09:00,490
condició de la nostra do while era cert.

162
00:09:00,490 --> 00:09:04,690
Quan li donem un nombre positiu, igual que 8, llavors el

163
00:09:04,690 --> 00:09:08,560
condició de la nostra do while ja no és cert.

164
00:09:08,560 --> 00:09:12,080
Així que el bucle no s'executa de nou.

165
00:09:12,080 --> 00:09:15,290
I això és tot pels tres tipus de bucles que usarem en C.

166
00:09:15,290 --> 00:09:18,840
El meu nom és Tommy, i això és CS50.