1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Review] [Quiz 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Ross, Tommy MacWilliam, Lluc Freitas, Joseph Ong] [Harvard University]

3
00:00:05,000 --> 00:00:08,000
>> [Aquesta és CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Ei, tothom.

5
00:00:10,000 --> 00:00:15,000
Benvinguts a la sessió de revisió per Quiz 0, que se celebra aquest dimecres.

6
00:00:15,000 --> 00:00:19,000
El que farem aquesta nit, estic amb 3 altres FF,

7
00:00:19,000 --> 00:00:24,000
i junts anirem a través d'una revisió del que hem fet en el curs fins ara.

8
00:00:24,000 --> 00:00:27,000
No serà 100% complet, però ha de donar una idea millor

9
00:00:27,000 --> 00:00:31,000
del que ja té i pel que encara ha d'estudiar abans de dimecres.

10
00:00:31,000 --> 00:00:34,000
I no dubteu a aixecar la mà amb preguntes com anem al llarg,

11
00:00:34,000 --> 00:00:38,000
però tingui en compte que també tindrem una mica de temps al final-

12
00:00:38,000 --> 00:00:41,000
si aconseguim a través d'uns minuts de sobres per fer preguntes generals,

13
00:00:41,000 --> 00:00:47,000
així que tingues-ho en ment, així que anem a començar des del principi amb la Setmana 0.

14
00:00:47,000 --> 00:00:50,000
>> [Concurs 0 Review!] [Part 0] [Lexi Ross] Però abans de fer això parlarem de

15
00:00:50,000 --> 00:00:53,000
la logística de la prova.

16
00:00:53,000 --> 00:00:55,000
>> [Logística] [Concurs tindrà lloc el dimecres 10/10 en lloc de la conferència]

17
00:00:55,000 --> 00:00:57,000
>> [(Veure http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf per més detalls)] És el dimecres, 10 d'octubre.

18
00:00:57,000 --> 00:01:00,000
>> Això és avui, i si vas a aquesta URL aquí

19
00:01:00,000 --> 00:01:03,000
que també és accessible des CS50.net-aquí 's un enllaç a ella-

20
00:01:03,000 --> 00:01:06,000
pot veure informació sobre on anar sobre la base de

21
00:01:06,000 --> 00:01:10,000
seu cognom o afiliació escolar, així com

22
00:01:10,000 --> 00:01:14,000
es parla exactament el que la prova inclourà i els tipus de preguntes que vostè va a obtenir.

23
00:01:14,000 --> 00:01:19,000
Tingueu en compte que vostè també tindrà l'oportunitat de revisar el qüestionari a la secció,

24
00:01:19,000 --> 00:01:21,000
pel que els seus TFS ha d'anar sobre alguns problemes de la pràctica,

25
00:01:21,000 --> 00:01:29,000
i aquesta és una altra bona oportunitat per veure d'on vostè encara ha d'estudiar per l'examen.

26
00:01:29,000 --> 00:01:32,000
Anem a començar des del principi amb bytes 'n' Bits.

27
00:01:32,000 --> 00:01:35,000
Recordeu que un bit és un 0 o un 1,

28
00:01:35,000 --> 00:01:38,000
i un byte és una col · lecció de 8 d'aquests bits.

29
00:01:38,000 --> 00:01:42,000
Fem una ullada a aquesta col · lecció de bits aquí.

30
00:01:42,000 --> 00:01:44,000
Hem de ser capaços d'esbrinar quants bits hi.

31
00:01:44,000 --> 00:01:48,000
On s'explica que hi ha només 8 d'ells, vuit 0 o 1 unitats.

32
00:01:48,000 --> 00:01:51,000
I ja que hi ha 8 bits, això és 1 byte,

33
00:01:51,000 --> 00:01:53,000
i anem a convertir hexadecimal.

34
00:01:53,000 --> 00:01:58,000
Hexadecimal és base 16, i és bastant fàcil de convertir

35
00:01:58,000 --> 00:02:01,000
en un nombre binari, que és el que és, a un nombre en hexadecimal.

36
00:02:01,000 --> 00:02:04,000
Tot el que fem és mirar en grups de 4,

37
00:02:04,000 --> 00:02:07,000
i convertir-los al dígit hexadecimal corresponent.

38
00:02:07,000 --> 00:02:11,000
Comencem amb el grup de més a la dreta de 4, així que 0011.

39
00:02:11,000 --> 00:02:16,000
Això serà un 1 i un 2, de manera que en conjunt fa 3.

40
00:02:16,000 --> 00:02:19,000
I després veurem l'altre bloc de 4.

41
00:02:19,000 --> 00:02:24,000
1101. Això serà un 1, un 4 i un 8.

42
00:02:24,000 --> 00:02:28,000
Al costat això serà de 13, el que fa D.

43
00:02:28,000 --> 00:02:32,000
I recordarem que en hexadecimal no ens limitem a anar del 0 al 9.

44
00:02:32,000 --> 00:02:36,000
Anem 0 a F, de manera que després de 9, 10 correspon a A,

45
00:02:36,000 --> 00:02:40,000
11 a B, etc, on F és 15.

46
00:02:40,000 --> 00:02:44,000
Aquí 13 és una D,

47
00:02:44,000 --> 00:02:49,000
pel que per convertir decimal tot el que fem és en realitat

48
00:02:49,000 --> 00:02:52,000
tractar cada posició com una potència de 2.

49
00:02:52,000 --> 00:02:58,000
Aquesta és una de 1, un 2, zero 4s, 8s zero, un 16, etcètera,

50
00:02:58,000 --> 00:03:03,000
i és una mica difícil de calcular al cap, però si anem a la següent diapositiva

51
00:03:03,000 --> 00:03:05,000
podem veure la resposta a això.

52
00:03:05,000 --> 00:03:09,000
>> Essencialment anem a l'altre costat de la dreta de nou a l'esquerra,

53
00:03:09,000 --> 00:03:14,000
i estem multiplicant cada dígit per la corresponent potència de 2.

54
00:03:14,000 --> 00:03:19,000
I recorda, per hexadecimal que denoten aquestes xifres amb 0x al principi

55
00:03:19,000 --> 00:03:23,000
així que no ho confongui amb un nombre decimal.

56
00:03:23,000 --> 00:03:29,000
Continuant, aquesta és una taula ASCII,

57
00:03:29,000 --> 00:03:35,000
i el que utilitzi ASCII per és mapejar de caràcters a valors numèrics.

58
00:03:35,000 --> 00:03:39,000
Recordeu que en el conjunt de processadors criptografia hem fet un ús extensiu de la taula ASCII

59
00:03:39,000 --> 00:03:43,000
per tal d'utilitzar diversos mètodes de criptografia,

60
00:03:43,000 --> 00:03:47,000
el Cèsar i el xifrat de Vigenère, per convertir lletres diferents

61
00:03:47,000 --> 00:03:52,000
en una cadena d'acord amb la clau proporcionada per l'usuari.

62
00:03:52,000 --> 00:03:56,000
Anem a veure una mica de matemàtiques ASCII.

63
00:03:56,000 --> 00:04:02,000
Quant a 'P' + 1, en format de caràcters que seria Q,

64
00:04:02,000 --> 00:04:07,000
i recorda que '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
I com podríem convertir entre aquestes 2 formes?

66
00:04:10,000 --> 00:04:13,000
No és en realitat massa dura.

67
00:04:13,000 --> 00:04:16,000
Per tal d'obtenir 5 restem '0 '

68
00:04:16,000 --> 00:04:20,000
perquè hi ha 5 llocs entre el 0 i el '5 '.

69
00:04:20,000 --> 00:04:23,000
Per tal d'anar cap a l'altre que només ha d'afegir el 0,

70
00:04:23,000 --> 00:04:25,000
pel que és una mena d'aritmètica regular.

71
00:04:25,000 --> 00:04:29,000
Només recordeu que quan alguna cosa té cometes al voltant d'ell que és un personatge

72
00:04:29,000 --> 00:04:37,000
i per tant correspon a un valor en la taula ASCII.

73
00:04:37,000 --> 00:04:40,000
Entrant en temes més generals d'informàtica.

74
00:04:40,000 --> 00:04:43,000
Ens assabentem del que un algorisme és i com s'utilitza la programació

75
00:04:43,000 --> 00:04:45,000
per implementar algorismes.

76
00:04:45,000 --> 00:04:48,000
Alguns exemples d'algorismes són alguna cosa realment simple, com

77
00:04:48,000 --> 00:04:51,000
comprovar si un nombre és parell o senar.

78
00:04:51,000 --> 00:04:54,000
Per als que es recorden de nosaltres mod el nombre per 2 i comprovar si el resultat és 0.

79
00:04:54,000 --> 00:04:57,000
Si és així, és encara. Si no és així, és estrany.

80
00:04:57,000 --> 00:04:59,000
I això és un exemple d'un algorisme molt bàsic.

81
00:04:59,000 --> 00:05:02,000
>> Una mica d'una major participació és la recerca binària,

82
00:05:02,000 --> 00:05:05,000
que anem a repassar més tard a la sessió de revisió.

83
00:05:05,000 --> 00:05:09,000
I la programació és el terme que fem servir per prendre un algorisme

84
00:05:09,000 --> 00:05:15,000
i la conversió a codificar l'ordinador pot llegir.

85
00:05:15,000 --> 00:05:20,000
2 exemples de programació Scratch,

86
00:05:20,000 --> 00:05:22,000
que és el que vam fer a la setmana 0.

87
00:05:22,000 --> 00:05:25,000
Tot i que en realitat no s'escriu el codi és una forma d'implementar

88
00:05:25,000 --> 00:05:29,000
aquest algorisme, que és la impressió dels números 1-10,

89
00:05:29,000 --> 00:05:32,000
i aquí fem el mateix en el llenguatge de programació C.

90
00:05:32,000 --> 00:05:41,000
Aquests són funcionalment equivalents, acaba d'escriure en diferents idiomes o de sintaxi.

91
00:05:41,000 --> 00:05:44,000
Després ens assabentem sobre les expressions booleanes,

92
00:05:44,000 --> 00:05:48,000
i un booleà és un valor que és vertader o fals,

93
00:05:48,000 --> 00:05:51,000
i aquí moltes vegades booleana

94
00:05:51,000 --> 00:05:55,000
anar dins de les condicions, així que si (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
bo, ia establir x = 5, de manera que l'estat es va a avaluar en true.

96
00:06:00,000 --> 00:06:03,000
I si és veritable, tot el codi està per sota de la condició

97
00:06:03,000 --> 00:06:08,000
serà avaluat per l'ordinador, de manera que cadena s'ha d'imprimir

98
00:06:08,000 --> 00:06:12,000
la sortida estàndard, i la condició de terme

99
00:06:12,000 --> 00:06:16,000
es refereix a tot el que està dins dels parèntesis de la instrucció if.

100
00:06:16,000 --> 00:06:20,000
Recordeu que tots els operadors.

101
00:06:20,000 --> 00:06:26,000
Recorda que és && i | | quan estem tractant de combinar 2 o més condicions,

102
00:06:26,000 --> 00:06:30,000
== No = per comprovar si dues coses són iguals.

103
00:06:30,000 --> 00:06:36,000
Recordeu que és = per a l'assignació mentre == és un operador booleà.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ i després la final 2 són fàcils d'entendre.

105
00:06:41,000 --> 00:06:45,000
Una revisió general de la lògica booleana aquí.

106
00:06:45,000 --> 00:06:48,000
I booleana són també importants en bucles,

107
00:06:48,000 --> 00:06:50,000
que anem a repassar ara.

108
00:06:50,000 --> 00:06:56,000
Vam aprendre unes 3 tipus de bucles des de començament CS50, for, while i do temps.

109
00:06:56,000 --> 00:06:59,000
I és important saber que mentre per a la majoria dels propòsits

110
00:06:59,000 --> 00:07:02,000
de fet podem utilitzar qualsevol tipus de bucle en general

111
00:07:02,000 --> 00:07:06,000
hi ha certs tipus de propòsits o patrons comuns

112
00:07:06,000 --> 00:07:09,000
en la programació que específicament trucar a un d'aquests bucles

113
00:07:09,000 --> 00:07:13,000
fer que el. més eficient o elegant per codificar d'aquesta manera

114
00:07:13,000 --> 00:07:18,000
Anem a repassar el que cada un d'aquests bucles se sol utilitzar per més freqüència.

115
00:07:18,000 --> 00:07:21,000
>> En un bucle for en general, ja sé quantes vegades volem repetir.

116
00:07:21,000 --> 00:07:24,000
Això és el que posem en la condició.

117
00:07:24,000 --> 00:07:28,000
Per, i = 0, i <10, per exemple.

118
00:07:28,000 --> 00:07:31,000
Ja sabem que volem fer alguna cosa 10 vegades.

119
00:07:31,000 --> 00:07:34,000
Ara, per un bucle while, en general, no necessàriament

120
00:07:34,000 --> 00:07:36,000
sé quantes vegades volem que el bucle s'executi.

121
00:07:36,000 --> 00:07:39,000
Però sí sabem algun tipus de condició que volem que

122
00:07:39,000 --> 00:07:41,000
sempre és veritable o sempre falsa.

123
00:07:41,000 --> 00:07:44,000
Per exemple, mentre que s'estableix.

124
00:07:44,000 --> 00:07:46,000
Diguem que és una variable booleana.

125
00:07:46,000 --> 00:07:48,000
Si bé és cert que volem que el codi per avaluar,

126
00:07:48,000 --> 00:07:52,000
així que una mica més extensible, una mica més general que un bucle for,

127
00:07:52,000 --> 00:07:55,000
però per a qualsevol bucle també es pot convertir en un bucle while.

128
00:07:55,000 --> 00:08:00,000
Finalment, fer bucles while, que poden ser els més difícils de comprendre immediatament,

129
00:08:00,000 --> 00:08:04,000
s'utilitza sovint quan volem avaluar el primer codi

130
00:08:04,000 --> 00:08:06,000
abans de la primera vegada que comprovi l'estat.

131
00:08:06,000 --> 00:08:09,000
Un cas d'ús comú que un cicle do while

132
00:08:09,000 --> 00:08:12,000
és quan es vol aconseguir l'entrada de l'usuari, i vostè sap que vostè vol preguntar a l'usuari

133
00:08:12,000 --> 00:08:15,000
per a l'entrada d'almenys una vegada, però si no et donen una bona entrada immediatament

134
00:08:15,000 --> 00:08:18,000
vol seguir preguntant fins que et donen la bona entrada.

135
00:08:18,000 --> 00:08:21,000
Aquest és l'ús més comú d'un bucle Do While,

136
00:08:21,000 --> 00:08:23,000
i donem una ullada a l'estructura real d'aquests bucles.

137
00:08:23,000 --> 00:08:27,000
En general sempre tendeixen a seguir aquests patrons.

138
00:08:27,000 --> 00:08:30,000
>> En el bucle per l'interior té 3 components:

139
00:08:30,000 --> 00:08:35,000
inicialització, en general alguna cosa com int i = 0 on i és el comptador,

140
00:08:35,000 --> 00:08:40,000
condició, on volem dir per executar aquest bucle, sempre que aquesta situació encara es manté,

141
00:08:40,000 --> 00:08:44,000
com i <10, i, finalment, l'actualització, que és com incrementem

142
00:08:44,000 --> 00:08:47,000
la variable de comptador en cada punt en el bucle.

143
00:08:47,000 --> 00:08:50,000
Una cosa comuna veure només hi ha i + +,

144
00:08:50,000 --> 00:08:52,000
el que significa incrementar ia 1 cada vegada.

145
00:08:52,000 --> 00:08:55,000
També es podria fer alguna cosa com i + = 2,

146
00:08:55,000 --> 00:08:58,000
el que significa afegir 2 a i cada vegada que vagi a través del bucle.

147
00:08:58,000 --> 00:09:03,000
I a continuació, el fer això només es refereix a qualsevol codi que realment s'executa com a part del bucle.

148
00:09:03,000 --> 00:09:09,000
I per un bucle while, aquesta vegada en realitat tenim la inicialització fora del bucle,

149
00:09:09,000 --> 00:09:12,000
així per exemple, diguem que estem tractant de fer el mateix tipus de bucle, com acabo de descriure.

150
00:09:12,000 --> 00:09:16,000
Diríem int i = 0 abans del bucle comença.

151
00:09:16,000 --> 00:09:20,000
Llavors podríem dir que mentre i <10 fer això,

152
00:09:20,000 --> 00:09:22,000
de manera que el mateix bloc de codi com abans,

153
00:09:22,000 --> 00:09:26,000
i aquesta vegada la part d'actualització del codi, per exemple, i + +,

154
00:09:26,000 --> 00:09:29,000
en realitat va dins del bucle.

155
00:09:29,000 --> 00:09:33,000
I finalment, per fer una estona, és similar al bucle while,

156
00:09:33,000 --> 00:09:36,000
però hem de recordar que el codi s'avaluarà una vegada

157
00:09:36,000 --> 00:09:40,000
abans que la condició es comprova, per la qual cosa té molt més sentit

158
00:09:40,000 --> 00:09:44,000
si ens fixem en ella per tal de dalt a baix.

159
00:09:44,000 --> 00:09:49,000
En una, do while avalua el codi, fins i tot abans de veure la condició mentre

160
00:09:49,000 --> 00:09:55,000
mentre que un bucle while, comprova en primer lloc.

161
00:09:55,000 --> 00:09:59,000
Les declaracions i variables.

162
00:09:59,000 --> 00:10:04,000
Quan volem crear una nova variable que primer vol inicialitzar.

163
00:10:04,000 --> 00:10:07,000
>> Per exemple, la barra int inicialitza la variable bar,

164
00:10:07,000 --> 00:10:10,000
però no li dóna un valor, llavors quin és el valor de la barra ara?

165
00:10:10,000 --> 00:10:12,000
No ho sé.

166
00:10:12,000 --> 00:10:14,000
Podria ser un valor escombraries que estava prèviament emmagatzemat en la memòria allà,

167
00:10:14,000 --> 00:10:16,000
i no volem utilitzar aquesta variable

168
00:10:16,000 --> 00:10:19,000
fins que realment li donen un valor,

169
00:10:19,000 --> 00:10:21,000
així ho declarem aquí.

170
00:10:21,000 --> 00:10:24,000
Després inicialitzem a ser 42.

171
00:10:24,000 --> 00:10:28,000
Ara, per descomptat, sabem que això es pot fer en una sola línia, bar int = 42.

172
00:10:28,000 --> 00:10:30,000
Però per ser clars els múltiples passos que s'estan produint,

173
00:10:30,000 --> 00:10:34,000
la declaració i inicialització estan succeint aquí per separat.

174
00:10:34,000 --> 00:10:38,000
Això passa en un sol pas, i el següent, int = bar baz + 1,

175
00:10:38,000 --> 00:10:44,000
aquesta declaració de baix, que baz increments, de manera que al final d'aquest bloc de codi

176
00:10:44,000 --> 00:10:48,000
si haguéssim de imprimir el valor de baz seria 44

177
00:10:48,000 --> 00:10:52,000
perquè declarar i inicialitzar a ser d'1 bar>,

178
00:10:52,000 --> 00:10:58,000
i després l'incrementa un cop més amb el + +.

179
00:10:58,000 --> 00:11:02,000
Repassem breument aquesta bonica, però és bo tenir un general

180
00:11:02,000 --> 00:11:04,000
comprensió del que les discussions i els esdeveniments són.

181
00:11:04,000 --> 00:11:06,000
Principalment ens va fer això en Scratch,

182
00:11:06,000 --> 00:11:09,000
així que vostè pot pensar en temes com diverses seqüències de codi

183
00:11:09,000 --> 00:11:11,000
executant a la vegada.

184
00:11:11,000 --> 00:11:14,000
En realitat, és probable que no s'està executant a la vegada,

185
00:11:14,000 --> 00:11:17,000
sinó una mena de forma abstracta, podem pensar-hi d'aquesta manera.

186
00:11:17,000 --> 00:11:20,000
>> En Scratch, per exemple, vam tenir els sprites múltiples.

187
00:11:20,000 --> 00:11:22,000
Es podria executar codi diferent a la vegada.

188
00:11:22,000 --> 00:11:26,000
Un podia caminar mentre que l'altre està dient alguna cosa

189
00:11:26,000 --> 00:11:29,000
en una part diferent de la pantalla.

190
00:11:29,000 --> 00:11:34,000
Els esdeveniments són una altra manera de separar la lògica

191
00:11:34,000 --> 00:11:37,000
entre els diferents elements del seu codi,

192
00:11:37,000 --> 00:11:40,000
i en Scratch hem estat capaços de simular els esdeveniments utilitzant la difusió,

193
00:11:40,000 --> 00:11:43,000
i que en realitat és quan rebut, no quan sento,

194
00:11:43,000 --> 00:11:47,000
però en essència es tracta d'una forma de transmetre informació

195
00:11:47,000 --> 00:11:49,000
d'un sprite a un altre.

196
00:11:49,000 --> 00:11:52,000
Per exemple, és possible que vulgueu transmetre més de joc,

197
00:11:52,000 --> 00:11:56,000
i quan un altre follet rep més de joc,

198
00:11:56,000 --> 00:11:58,000
que respon d'una manera determinada.

199
00:11:58,000 --> 00:12:03,000
És un model important per entendre la programació.

200
00:12:03,000 --> 00:12:07,000
Només per passar la Setmana bàsic 0, el que hem anat fins ara,

201
00:12:07,000 --> 00:12:10,000
donem una ullada a aquest programa C simple.

202
00:12:10,000 --> 00:12:14,000
El text pot ser una mica més petita d'aquí, però vaig a anar-hi molt ràpid.

203
00:12:14,000 --> 00:12:20,000
Estem incloent dos arxius de capçalera a la part superior cs50.h i stdio.h.

204
00:12:20,000 --> 00:12:23,000
Estem llavors definir un límit constant cridat a ser 100.

205
00:12:23,000 --> 00:12:26,000
Estem llavors la implementació de la nostra funció principal.

206
00:12:26,000 --> 00:12:29,000
Com que no utilitza arguments de línia d'ordres aquí hem de posar buit

207
00:12:29,000 --> 00:12:32,000
com els arguments a favor principal.

208
00:12:32,000 --> 00:12:38,000
Veiem int dalt principal. Aquest és el tipus de retorn, per tant, tornar 0 a la part inferior.

209
00:12:38,000 --> 00:12:41,000
I estem fent servir la funció de biblioteca CS50 aconseguir int

210
00:12:41,000 --> 00:12:45,000
sol · licitar a l'usuari dades, i la emmagatzemem en aquesta variable x,

211
00:12:45,000 --> 00:12:51,000
de manera que declarem x dalt, i el inicialitza amb x = getInt.

212
00:12:51,000 --> 00:12:53,000
>> A continuació, comprovar per veure si l'usuari ens va donar bona entrada.

213
00:12:53,000 --> 00:12:59,000
Si es tracta d'LIMIT ≥ volem tornar un codi d'error d'1 i mostrarà un missatge d'error.

214
00:12:59,000 --> 00:13:02,000
I, finalment, si l'usuari ens ha donat bons aportacions

215
00:13:02,000 --> 00:13:08,000
anem a quadrar el nombre i imprimir el resultat.

216
00:13:08,000 --> 00:13:11,000
Només per assegurar-se que tots els afectats casa

217
00:13:11,000 --> 00:13:17,000
es pot veure les etiquetes de diferents parts del codi aquí.

218
00:13:17,000 --> 00:13:19,000
Esmentar arxius constants de capçalera.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Assegureu-vos recordar que és una variable local.

220
00:13:21,000 --> 00:13:24,000
Això contrasta d'una variable global, el que anem a parlar de

221
00:13:24,000 --> 00:13:27,000
una mica més endavant en la sessió de revisió,

222
00:13:27,000 --> 00:13:30,000
i estem cridant a la funció de biblioteca printf,

223
00:13:30,000 --> 00:13:34,000
així que si no havia inclòs l'arxiu de capçalera stdio.h

224
00:13:34,000 --> 00:13:37,000
no seria capaç de cridar a printf.

225
00:13:37,000 --> 00:13:42,000
I crec que la fletxa que es va tallar aquí està apuntant a la d%

226
00:13:42,000 --> 00:13:45,000
que és una cadena de format de printf.

227
00:13:45,000 --> 00:13:52,000
Diu imprimir aquesta variable com un nombre d%.

228
00:13:52,000 --> 00:13:58,000
I que és la Setmana de 0.

229
00:13:58,000 --> 00:14:06,000
Ara Lucas va a continuar.

230
00:14:06,000 --> 00:14:08,000
Hey, nois. El meu nom és Lluc.

231
00:14:08,000 --> 00:14:10,000
Sóc un estudiant de segon any a la millor casa al campus, Mather,

232
00:14:10,000 --> 00:14:14,000
i vaig a parlar una mica sobre la Setmana 1 i 2,1.

233
00:14:14,000 --> 00:14:16,000
[Setmana 1 i 2,1!] [Lluc Freitas]

234
00:14:16,000 --> 00:14:19,000
Com Lexi estava dient, quan vam començar a traduir el codi des de zero en C

235
00:14:19,000 --> 00:14:23,000
una de les coses que hem notat és que es pot no només

236
00:14:23,000 --> 00:14:26,000
escriure el codi i executar-lo amb una bandera verda més.

237
00:14:26,000 --> 00:14:30,000
En realitat, vostè ha d'utilitzar alguns passos per fer el seu programa en C

238
00:14:30,000 --> 00:14:33,000
convertir-se en un arxiu executable.

239
00:14:33,000 --> 00:14:36,000
Bàsicament el que fas quan estàs escrivint un programa és que

240
00:14:36,000 --> 00:14:40,000
traduir la seva idea en un llenguatge que un compilador pot entendre,

241
00:14:40,000 --> 00:14:44,000
així que quan vostè està escrivint un programa en C

242
00:14:44,000 --> 00:14:47,000
el que estàs fent és escriure realment una cosa que el compilador va a entendre,

243
00:14:47,000 --> 00:14:50,000
i el compilador traduirà aquest codi

244
00:14:50,000 --> 00:14:53,000
en alguna cosa que el seu equip va a entendre.

245
00:14:53,000 --> 00:14:55,000
>> I la cosa és que l'equip és realment molt ximple.

246
00:14:55,000 --> 00:14:57,000
L'equip només es pot entendre 0s i 1s,

247
00:14:57,000 --> 00:15:01,000
el que en realitat en els primers ordinadors gent sol programar

248
00:15:01,000 --> 00:15:04,000
amb 0 i 1, però ja no, gràcies a Déu.

249
00:15:04,000 --> 00:15:07,000
No hem de memoritzar les seqüències de 0s i 1s

250
00:15:07,000 --> 00:15:10,000
per a un bucle o per a un bucle while i així successivament.

251
00:15:10,000 --> 00:15:13,000
És per això que tenim un compilador.

252
00:15:13,000 --> 00:15:17,000
El que un compilador fa és que bàsicament es tradueix el codi C,

253
00:15:17,000 --> 00:15:21,000
en el nostre cas, de la llengua que l'equip va a entendre,

254
00:15:21,000 --> 00:15:25,000
que és el codi objecte, i el compilador que estem utilitzant

255
00:15:25,000 --> 00:15:30,000
es diu so metàl · lic, així que això és realment el símbol de so metàl · lic.

256
00:15:30,000 --> 00:15:33,000
Quan vostè té el seu programa, vostè ha de fer 2 coses.

257
00:15:33,000 --> 00:15:37,000
En primer lloc, vostè ha de compilar el programa, i després es va a executar el programa.

258
00:15:37,000 --> 00:15:41,000
Per compilar el programa té un munt d'opcions per fer-ho.

259
00:15:41,000 --> 00:15:44,000
La primera d'elles té a veure program.c clang

260
00:15:44,000 --> 00:15:47,000
en quin programa és el nom del programa.

261
00:15:47,000 --> 00:15:51,000
En aquest cas es pot veure que estan dient "Hey, compilar el meu programa".

262
00:15:51,000 --> 00:15:56,000
No està dient "Vull que aquest nom per el meu programa", ni res.

263
00:15:56,000 --> 00:15:58,000
>> La segona opció és donar un nom al seu programa.

264
00:15:58,000 --> 00:16:02,000
Es pot dir clang-o i després el nom que desitja

265
00:16:02,000 --> 00:16:06,000
l'arxiu executable per ser nomenat com i, a continuació program.c.

266
00:16:06,000 --> 00:16:11,000
I també es pot fer fer el programa, i veure com en els primers 2 casos

267
00:16:11,000 --> 00:16:15,000
Vaig posar. C, i en el tercer només tinc programes?

268
00:16:15,000 --> 00:16:18,000
Sí, en realitat no hauria de posar. C quan s'utilitza fer.

269
00:16:18,000 --> 00:16:22,000
En cas contrari el compilador és en realitat va a cridar a vostè.

270
00:16:22,000 --> 00:16:24,000
I també, no sé si vostès recorden,

271
00:16:24,000 --> 00:16:29,000
però moltes vegades també fem servir lcs50-o-lm.

272
00:16:29,000 --> 00:16:31,000
Això es diu enllaç.

273
00:16:31,000 --> 00:16:35,000
Simplement li diu al compilador que utilitzarà les biblioteques allà mateix,

274
00:16:35,000 --> 00:16:39,000
així que si vol utilitzar cs50.h que realment ha d'escriure

275
00:16:39,000 --> 00:16:43,000
clang program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Si no ho fa, el compilador no sabrà

277
00:16:45,000 --> 00:16:50,000
que utilitzeu aquestes funcions en cs50.h.

278
00:16:50,000 --> 00:16:52,000
I quan es vol executar el programa té 2 opcions.

279
00:16:52,000 --> 00:16:57,000
Si vostè va fer program.c clang vostè no ho hàgiu fet al seu programa.

280
00:16:57,000 --> 00:17:01,000
Vostè ha d'executar amb. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out és un nom estàndard que li dóna al seu so metàl · lic programa si no li donem un nom.

282
00:17:06,000 --> 00:17:11,000
En cas contrari, farem. / Programa si vostè li va donar un nom al seu programa,

283
00:17:11,000 --> 00:17:15,000
i també si ho has fet fer el programa el nom d'un programa que es posarà

284
00:17:15,000 --> 00:17:23,000
ja serà programat amb el mateix nom que l'arxiu c.

285
00:17:23,000 --> 00:17:26,000
Després parlem de tipus de dades i les dades.

286
00:17:26,000 --> 00:17:31,000
>> Bàsicament els tipus de dades són el mateix com petites caixes que utilitzen

287
00:17:31,000 --> 00:17:35,000
per emmagatzemar els valors, de manera que els tipus de dades són en realitat com Pokémons.

288
00:17:35,000 --> 00:17:39,000
Vénen en totes les mides i tipus.

289
00:17:39,000 --> 00:17:43,000
No sé si aquesta analogia té sentit.

290
00:17:43,000 --> 00:17:46,000
La mida de les dades depèn en realitat de l'arquitectura de la màquina.

291
00:17:46,000 --> 00:17:49,000
Totes les mides de dades que vaig a mostrar aquí

292
00:17:49,000 --> 00:17:53,000
són en realitat per a una màquina de 32-bit, que és el cas del nostre aparell,

293
00:17:53,000 --> 00:17:56,000
però si vostè està realment codificació del seu Mac o al Windows també

294
00:17:56,000 --> 00:17:59,000
Probablement vostè tindrà un equip de 64 bits,

295
00:17:59,000 --> 00:18:03,000
així que recordi que les mides de les dades que vaig a mostrar aquí

296
00:18:03,000 --> 00:18:06,000
són per a la màquina de 32-bit.

297
00:18:06,000 --> 00:18:08,000
El primer que vam veure va ser un int,

298
00:18:08,000 --> 00:18:10,000
que és bastant senzill.

299
00:18:10,000 --> 00:18:13,000
Utilitzeu int per emmagatzemar un sencer.

300
00:18:13,000 --> 00:18:16,000
També vam veure el caràcter, el char.

301
00:18:16,000 --> 00:18:20,000
Si voleu utilitzar una lletra o un símbol poc vostè està probablement va a utilitzar un char.

302
00:18:20,000 --> 00:18:26,000
Un char té 1 byte, és a dir 8 bits, com va dir Lexi.

303
00:18:26,000 --> 00:18:31,000
Bàsicament tenim una taula ASCII que té 256

304
00:18:31,000 --> 00:18:34,000
les possibles combinacions de 0s i 1s,

305
00:18:34,000 --> 00:18:37,000
i després, quan s'escriu una xerrada traduirà

306
00:18:37,000 --> 00:18:44,000
el caràcter que les entrades que un nombre que té a la taula ASCII, com va dir Lexi.

307
00:18:44,000 --> 00:18:48,000
També tenim el flotador, que utilitzem per emmagatzemar nombres decimals.

308
00:18:48,000 --> 00:18:53,000
Si vostè vol triar 3.14, per exemple, vostè ha d'utilitzar un flotador

309
00:18:53,000 --> 00:18:55,000
o un doble que té més precisió.

310
00:18:55,000 --> 00:18:57,000
Un flotador té 4 bytes.

311
00:18:57,000 --> 00:19:01,000
Un doble té 8 bytes, de manera que l'única diferència és la precisió.

312
00:19:01,000 --> 00:19:04,000
També tenim un llarg que s'utilitza per als nombres enters,

313
00:19:04,000 --> 00:19:09,000
i es pot veure una màquina de 32-bit 1 int i un llarg tenen la mateixa mida,

314
00:19:09,000 --> 00:19:13,000
pel que en realitat no té sentit utilitzar un llarg en una màquina de 32-bit.

315
00:19:13,000 --> 00:19:17,000
>> Però si vostè està utilitzant un Mac i de 64 bits, en realitat una llarga té una mida de 8,

316
00:19:17,000 --> 00:19:19,000
així que realment depèn de l'arquitectura.

317
00:19:19,000 --> 00:19:22,000
Perquè la màquina 32-bit no té sentit usar un llarg realitat.

318
00:19:22,000 --> 00:19:25,000
I després un llarg temps, d'altra banda, té 8 bytes,

319
00:19:25,000 --> 00:19:30,000
pel que és molt bo si vostè vol tenir un enter llarg.

320
00:19:30,000 --> 00:19:34,000
I finalment, hem cadena, que és en realitat un char *,

321
00:19:34,000 --> 00:19:37,000
que és un punter a un char.

322
00:19:37,000 --> 00:19:40,000
És molt fàcil pensar que la mida de la cadena serà com

323
00:19:40,000 --> 00:19:42,000
el nombre de caràcters que té allà,

324
00:19:42,000 --> 00:19:45,000
però en realitat el propi char *

325
00:19:45,000 --> 00:19:49,000
té la mida d'un punter a un char, que és 4 bytes.

326
00:19:49,000 --> 00:19:52,000
La mida d'un char * és de 4 bytes.

327
00:19:52,000 --> 00:19:56,000
No importa si vostè té una petita paraula o una lletra o gens.

328
00:19:56,000 --> 00:19:58,000
Serà de 4 bytes.

329
00:19:58,000 --> 00:20:01,000
També hem après una mica sobre càsting,

330
00:20:01,000 --> 00:20:04,000
Així com vostè pot veure, si vostè té, per exemple, un programa que diu:

331
00:20:04,000 --> 00:20:08,000
int x = 3 i després printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
Vostès saben el que voleu imprimir a la pantalla?

333
00:20:12,000 --> 00:20:14,000
>> Algú? >> [Els estudiants] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, sí.

335
00:20:16,000 --> 00:20:20,000
En fer 3/2 que obtindrà 1,5,

336
00:20:20,000 --> 00:20:24,000
però ja que estem usant un nombre enter que farà cas omís de la part decimal,

337
00:20:24,000 --> 00:20:26,000
i tindràs 1.

338
00:20:26,000 --> 00:20:29,000
Si vostè no vol que això succeeixi el que pot fer, per exemple,

339
00:20:29,000 --> 00:20:33,000
Es declara un flotador i = x.

340
00:20:33,000 --> 00:20:40,000
Llavors x que abans eren 3 ara serà 3,000 en i.

341
00:20:40,000 --> 00:20:44,000
I llavors vostè pot imprimir el a / 2.

342
00:20:44,000 --> 00:20:50,000
En realitat, jo hauria de tenir un 2. per allà.

343
00:20:50,000 --> 00:20:55,000
Farà 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
i obtindràs 1,5.

345
00:20:58,000 --> 00:21:06,000
I nosaltres tenim aquest f 0,2 només per demanar 2 unitats decimals de la part decimal.

346
00:21:06,000 --> 00:21:12,000
Si té 0,3 f que tindrà realment 1.500.

347
00:21:12,000 --> 00:21:16,000
Si es tracta de dues que serà 1,50.

348
00:21:16,000 --> 00:21:18,000
També tenim aquest cas.

349
00:21:18,000 --> 00:21:22,000
Si ho fa float x = 3,14 x i llavors vostè printf

350
00:21:22,000 --> 00:21:24,000
vostè va a obtenir 3,14.

351
00:21:24,000 --> 00:21:29,000
I si ho fa x = int x,

352
00:21:29,000 --> 00:21:34,000
el que significa tractar x com un enter i s'imprimeix x ara

353
00:21:34,000 --> 00:21:36,000
vostè tindrà 3,00.

354
00:21:36,000 --> 00:21:38,000
Això té sentit?

355
00:21:38,000 --> 00:21:41,000
Com que vostè està tractant primerament x com un enter, pel que està fent cas omís de la part decimal,

356
00:21:41,000 --> 00:21:45,000
i després imprimeix x.

357
00:21:45,000 --> 00:21:47,000
I, finalment, també es pot fer això,

358
00:21:47,000 --> 00:21:52,000
int x = 65, i llavors es declara un char c = x,

359
00:21:52,000 --> 00:21:56,000
i després, si s'imprimeix el c estàs realment va a aconseguir

360
00:21:56,000 --> 00:21:59,000
A, així que bàsicament el que estàs fent aquí

361
00:21:59,000 --> 00:22:02,000
està traduint el sencer en el caràcter,

362
00:22:02,000 --> 00:22:05,000
igual que la taula ASCII fa.

363
00:22:05,000 --> 00:22:08,000
També parlem dels operadors matemàtics.

364
00:22:08,000 --> 00:22:14,000
La majoria d'ells són bastant senzills, de manera que +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
i també parlem de mod, que és la resta d'una divisió de dos nombres.

366
00:22:20,000 --> 00:22:23,000
Si té 10% 3, per exemple,

367
00:22:23,000 --> 00:22:27,000
que significa dividir 10 per 3, i el que és la resta?

368
00:22:27,000 --> 00:22:30,000
Serà 1, pel que és realment molt útil per a molts dels programes.

369
00:22:30,000 --> 00:22:38,000
Per Vigenère i César estic bastant segur que tots vostès utilitzen mod.

370
00:22:38,000 --> 00:22:43,000
Operadors matemàtics, tingui molta cura en combinar * i /.

371
00:22:43,000 --> 00:22:48,000
>> Per exemple, si vostè fa (3/2) * 2 Què vols aconseguir?

372
00:22:48,000 --> 00:22:50,000
[Els estudiants] 2.

373
00:22:50,000 --> 00:22:54,000
Sí, 2, perquè 3/2 serà 1,5,

374
00:22:54,000 --> 00:22:57,000
però ja que estem fent operacions entre dos nombres enters

375
00:22:57,000 --> 00:22:59,000
en realitat estàs sol tindrà en compte 1,

376
00:22:59,000 --> 00:23:03,000
i després 1 * 2 serà de 2, així que vés amb compte

377
00:23:03,000 --> 00:23:07,000
en fer aritmètica amb nombres enters perquè

378
00:23:07,000 --> 00:23:12,000
és possible que aconsegueixi que 2 = 3, en aquest cas.

379
00:23:12,000 --> 00:23:14,000
I també tenir molta cura amb prioritat.

380
00:23:14,000 --> 00:23:21,000
Generalment, vostè ha d'usar parèntesis per estar segur que vostè sap el que està fent.

381
00:23:21,000 --> 00:23:27,000
Alguns dreceres útils, és clar, es tracta d'i + + o i + = 1

382
00:23:27,000 --> 00:23:30,000
o usant + =.

383
00:23:30,000 --> 00:23:34,000
Això és el mateix que fer i = i + 1.

384
00:23:34,000 --> 00:23:39,000
També puc fer - o i - = 1,

385
00:23:39,000 --> 00:23:42,000
que és el mateix que i = i -1,

386
00:23:42,000 --> 00:23:46,000
cosa que vostès utilitzar en els bucles for, si més no.

387
00:23:46,000 --> 00:23:52,000
A més, per *, si utilitzeu * = i si ho fa, per exemple,

388
00:23:52,000 --> 00:23:57,000
i * = 2 és el mateix que dir i = i * 2,

389
00:23:57,000 --> 00:23:59,000
i el mateix per a la divisió.

390
00:23:59,000 --> 00:24:08,000
Si ho fa i / = 2 és el mateix que i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Ara, sobre les funcions.

392
00:24:10,000 --> 00:24:13,000
Vostès van aprendre que les funcions són una estratègia molt bona per guardar el codi

393
00:24:13,000 --> 00:24:16,000
mentre que vostè està programant, així que si vol dur a terme la mateixa tasca

394
00:24:16,000 --> 00:24:20,000
en el codi una i altra vegada, probablement vulgui utilitzar una funció

395
00:24:20,000 --> 00:24:25,000
només perquè vostè no ha de copiar i enganxar el codi una i altra vegada.

396
00:24:25,000 --> 00:24:28,000
En realitat, la principal és una funció, i quan et mostren el format d'una funció

397
00:24:28,000 --> 00:24:32,000
veuràs que això és bastant obvi.

398
00:24:32,000 --> 00:24:35,000
També utilitzem les funcions d'algunes biblioteques,

399
00:24:35,000 --> 00:24:39,000
per exemple, printf, Getin, que és de la biblioteca CS50,

400
00:24:39,000 --> 00:24:43,000
i altres funcions com ToUpper.

401
00:24:43,000 --> 00:24:46,000
Totes aquestes funcions es duen a la pràctica altres biblioteques,

402
00:24:46,000 --> 00:24:49,000
i quan es posa els arxius de subjecció al principi del seu programa

403
00:24:49,000 --> 00:24:53,000
que dius pot donar-me el codi per a les funcions

404
00:24:53,000 --> 00:24:57,000
així que no has de posar-les en pràctica per mi mateix?

405
00:24:57,000 --> 00:25:00,000
I vostè també pot escriure les seves pròpies funcions, de manera que en iniciar la programació

406
00:25:00,000 --> 00:25:04,000
t'adones que les biblioteques no tenen totes les funcions que vostè necessita.

407
00:25:04,000 --> 00:25:10,000
Per al conjunt de processadors passat, per exemple, escrivim dibuixar, lluita i recerca,

408
00:25:10,000 --> 00:25:13,000
i és molt, molt important ser capaç d'escriure funcions

409
00:25:13,000 --> 00:25:17,000
perquè són útils, i els fem servir tot el temps en la programació,

410
00:25:17,000 --> 00:25:19,000
i s'estalvia una gran quantitat de codi.

411
00:25:19,000 --> 00:25:21,000
El format d'una funció és aquest.

412
00:25:21,000 --> 00:25:24,000
Comptem amb tipus de retorn al principi. Quin és el tipus de canvi?

413
00:25:24,000 --> 00:25:27,000
És només quan la seva funció es tornarà.

414
00:25:27,000 --> 00:25:29,000
Si disposa d'una funció, per exemple, factorial,

415
00:25:29,000 --> 00:25:31,000
que es va a calcular un factorial d'un nombre enter,

416
00:25:31,000 --> 00:25:34,000
és probable que el tornarà un enter també.

417
00:25:34,000 --> 00:25:37,000
A continuació, el tipus de retorn serà int.

418
00:25:37,000 --> 00:25:41,000
Printf en realitat té un tipus de retorn void

419
00:25:41,000 --> 00:25:43,000
perquè no s'està tornant una mica.

420
00:25:43,000 --> 00:25:45,000
No ets més que la impressió de les coses a la pantalla

421
00:25:45,000 --> 00:25:48,000
i sortida de la funció després.

422
00:25:48,000 --> 00:25:51,000
Llavors vostè té el nom de la funció que vostè pot triar.

423
00:25:51,000 --> 00:25:55,000
Vostè ha de ser una mica raonable, igual que no tria un nom com xyz

424
00:25:55,000 --> 00:25:58,000
o com x2F.

425
00:25:58,000 --> 00:26:02,000
Intenta fer un nom que tingui sentit.

426
00:26:02,000 --> 00:26:04,000
>> Per exemple, si és factorial, diguem factorial.

427
00:26:04,000 --> 00:26:08,000
Si es tracta d'una funció que es va a dibuixar alguna cosa, el nom de dibuixar.

428
00:26:08,000 --> 00:26:11,000
I després tenim als paràmetres, que també s'anomenen arguments,

429
00:26:11,000 --> 00:26:14,000
que són com els recursos que necessita la seva funció

430
00:26:14,000 --> 00:26:17,000
a partir del seu codi per realitzar la seva tasca.

431
00:26:17,000 --> 00:26:20,000
Per calcular el factorial d'un nombre

432
00:26:20,000 --> 00:26:23,000
Probablement cal tenir un nombre per calcular un factorial.

433
00:26:23,000 --> 00:26:27,000
Un dels arguments que tindrem és el mateix nombre.

434
00:26:27,000 --> 00:26:31,000
I després es farà alguna cosa i tornar el valor al final

435
00:26:31,000 --> 00:26:35,000
si no és una funció void.

436
00:26:35,000 --> 00:26:37,000
Vegem un exemple.

437
00:26:37,000 --> 00:26:40,000
Si vull escriure una funció que sumi tots els nombres en una matriu d'enters,

438
00:26:40,000 --> 00:26:43,000
en primer lloc, el tipus de retorn serà int

439
00:26:43,000 --> 00:26:46,000
perquè tinc una matriu d'enters.

440
00:26:46,000 --> 00:26:51,000
I llavors em vaig a tenir el nom de la funció com sumArray,

441
00:26:51,000 --> 00:26:54,000
i llavors tindrà el mateix array, int núms a,

442
00:26:54,000 --> 00:26:58,000
i llavors la longitud de la matriu, així que sé la quantitat de nombres que cal sumar.

443
00:26:58,000 --> 00:27:02,000
Llavors ha de inicialitzar una variable anomenada suma, per exemple, a 0,

444
00:27:02,000 --> 00:27:08,000
i cada vegada que veig a un element de la matriu que hauria afegir a la suma, així que vaig fer un bucle for.

445
00:27:08,000 --> 00:27:15,000
Com va dir Lexi, oi int i = 0, i longitud <i + + i.

446
00:27:15,000 --> 00:27:20,000
I per cada element de la matriu que vaig fer suma + = núms [i],

447
00:27:20,000 --> 00:27:24,000
i després em va tornar la suma, pel que és molt simple, i s'estalvia una gran quantitat de codi

448
00:27:24,000 --> 00:27:28,000
si vostè està utilitzant aquesta funció un munt de vegades.

449
00:27:28,000 --> 00:27:32,000
A continuació, fem un cop d'ull a les condicions.

450
00:27:32,000 --> 00:27:38,000
Tenim if, else, i si una altra cosa.

451
00:27:38,000 --> 00:27:42,000
Anem a veure quina és la diferència entre ells.

452
00:27:42,000 --> 00:27:45,000
Fes un cop d'ull a aquests 2 codis. Quina és la diferència entre ells?

453
00:27:45,000 --> 00:27:49,000
El primer ha-bàsicament els codis que li diguis a

454
00:27:49,000 --> 00:27:51,000
si un nombre és +, -, o 0.

455
00:27:51,000 --> 00:27:55,000
La primera diu que si és> 0, llavors és positiu.

456
00:27:55,000 --> 00:28:00,000
Si és = a 0, llavors és 0, i si és <0, llavors és negatiu.

457
00:28:00,000 --> 00:28:04,000
>> I l'altre està fent if, else if, else.

458
00:28:04,000 --> 00:28:07,000
La diferència entre els dos és que aquest és en realitat serà

459
00:28:07,000 --> 00:28:13,000
comprovar si> 0, <0 = 0 o tres vegades,

460
00:28:13,000 --> 00:28:17,000
així que si vostè té el número 2, per exemple, vindrà aquí i dir

461
00:28:17,000 --> 00:28:21,000
if (x> 0), i que dirà que sí, així d'imprimir positiu.

462
00:28:21,000 --> 00:28:25,000
Però encara que sé que és> 0 i que no serà 0 o <0

463
00:28:25,000 --> 00:28:29,000
Jo encara vaig a fer és 0, és <0,

464
00:28:29,000 --> 00:28:33,000
així que estic realment va dins de IFS que jo no havia de

465
00:28:33,000 --> 00:28:38,000
perquè ja sabem que no va a satisfer alguna d'aquestes condicions.

466
00:28:38,000 --> 00:28:41,000
Puc utilitzar el if, else if, else declaració.

467
00:28:41,000 --> 00:28:45,000
Bàsicament diu que si x = 0 imprimeixo el positiu.

468
00:28:45,000 --> 00:28:48,000
Si no és així, vaig a provar això també.

469
00:28:48,000 --> 00:28:51,000
Si és 2, no faré això.

470
00:28:51,000 --> 00:28:54,000
Bàsicament si tingués x = 2 li diria

471
00:28:54,000 --> 00:28:57,000
if (x> 0), sí, així d'imprimir això.

472
00:28:57,000 --> 00:29:00,000
Ara que sé que és> 0 i que satisfà la primera, si

473
00:29:00,000 --> 00:29:02,000
Jo ni tan sols vaig a executar aquest codi.

474
00:29:02,000 --> 00:29:09,000
El codi s'executa més ràpid, en realitat, tres vegades més ràpid si els fas servir.

475
00:29:09,000 --> 00:29:11,000
També vam aprendre sobre AND i OR.

476
00:29:11,000 --> 00:29:15,000
No vaig a passar per això perquè Lexi ja parlava d'ells.

477
00:29:15,000 --> 00:29:17,000
És només el && i | operador |.

478
00:29:17,000 --> 00:29:21,000
>> L'únic que diré és anar amb compte quan vostè té 3 condicions.

479
00:29:21,000 --> 00:29:24,000
Utilitzeu parèntesis perquè és molt confús quan vostè té una condició

480
00:29:24,000 --> 00:29:27,000
i un altre o un a l'altre.

481
00:29:27,000 --> 00:29:30,000
Utilitzeu parèntesis per estar segur que les seves condicions de tenir sentit

482
00:29:30,000 --> 00:29:34,000
perquè en aquest cas, per exemple, es pot imaginar que

483
00:29:34,000 --> 00:29:38,000
podria ser la primera condició i una o l'altra

484
00:29:38,000 --> 00:29:41,000
o les dues condicions combinades en una i

485
00:29:41,000 --> 00:29:45,000
o el tercer, així que vés amb compte.

486
00:29:45,000 --> 00:29:48,000
I finalment, hem parlat sobre els modificadors.

487
00:29:48,000 --> 00:29:53,000
Un interruptor és molt útil quan es té una variable.

488
00:29:53,000 --> 00:29:55,000
Diguem que vostè té una variable com n

489
00:29:55,000 --> 00:29:59,000
que pot ser 0, 1, o 2, i per a cada un dels casos

490
00:29:59,000 --> 00:30:01,000
vostè va a realitzar una tasca.

491
00:30:01,000 --> 00:30:04,000
Es pot dir canviar la variable, i indica que

492
00:30:04,000 --> 00:30:08,000
el valor és, doncs, com valor1 vaig a fer això,

493
00:30:08,000 --> 00:30:12,000
i després trenco, el que significa que no vaig a mirar en qualsevol dels altres casos

494
00:30:12,000 --> 00:30:15,000
perquè ja convençut que el cas

495
00:30:15,000 --> 00:30:20,000
i després valor2 i així successivament, i també pot tenir un interruptor predeterminat.

496
00:30:20,000 --> 00:30:24,000
Això vol dir que si no satisfà qualsevol dels casos que he tingut

497
00:30:24,000 --> 00:30:29,000
que vaig a fer una altra cosa, però això és opcional.

498
00:30:29,000 --> 00:30:36,000
Això és tot per a mi. Ara anem a Tommy.

499
00:30:36,000 --> 00:30:41,000
Molt bé, això serà la setmana 3-ish.

500
00:30:41,000 --> 00:30:45,000
Aquests són alguns dels temes que tractarem, crypto, abast, matrius, etc.

501
00:30:45,000 --> 00:30:49,000
Només un breu comentari sobre criptografia. No anem a recalcar aquest.

502
00:30:49,000 --> 00:30:52,000
>> Ho vam fer en conjunt de processadors 2, però per a la prova assegura't de saber la diferència

503
00:30:52,000 --> 00:30:54,000
entre el xifrat César i el xifrat Vigenère,

504
00:30:54,000 --> 00:30:57,000
com dos funcionen aquestes xifres i el que és per xifrar

505
00:30:57,000 --> 00:30:59,000
i desxifrar el text usant aquests 2 xifres.

506
00:30:59,000 --> 00:31:03,000
Recordeu, el xifrat César simplement trencada cada personatge en la mateixa quantitat,

507
00:31:03,000 --> 00:31:06,000
assegurant-mod pel nombre de lletres en l'alfabet.

508
00:31:06,000 --> 00:31:09,000
I el xifrat de Vigenère, d'altra banda, fa girar cada caràcter

509
00:31:09,000 --> 00:31:12,000
per una suma diferent, així que en lloc de dir

510
00:31:12,000 --> 00:31:15,000
cada personatge gira per 3 Vigenère rotarà cada personatge

511
00:31:15,000 --> 00:31:17,000
per una quantitat diferent depenent d'alguna paraula clau

512
00:31:17,000 --> 00:31:20,000
on cada lletra de la paraula clau representa una certa quantitat diferent

513
00:31:20,000 --> 00:31:26,000
per girar el text clar.

514
00:31:26,000 --> 00:31:28,000
Parlarem primer d'abast variable.

515
00:31:28,000 --> 00:31:30,000
Hi ha 2 tipus diferents de variables.

516
00:31:30,000 --> 00:31:33,000
Tenim les variables locals, i aquests seran definits

517
00:31:33,000 --> 00:31:36,000
fora de principal o fora de qualsevol funció o bloc,

518
00:31:36,000 --> 00:31:39,000
i aquests seran accessibles en qualsevol part del seu programa.

519
00:31:39,000 --> 00:31:41,000
Si vostè té una funció i que en funció d'un bucle while

520
00:31:41,000 --> 00:31:44,000
la variable global gran és accessible a tot arreu.

521
00:31:44,000 --> 00:31:48,000
Una variable local, d'altra banda, té com aconseguir una posició en què està definida.

522
00:31:48,000 --> 00:31:53,000
>> Si vostè té una funció aquí, per exemple, tenim aquesta funció g,

523
00:31:53,000 --> 00:31:56,000
ia l'interior de g no és una variable anomenada aquí i,

524
00:31:56,000 --> 00:31:58,000
i això vol dir que es tracta d'una variable local.

525
00:31:58,000 --> 00:32:00,000
Tot i que aquesta variable es diu i

526
00:32:00,000 --> 00:32:03,000
i aquesta variable s'anomena I Aquestes 2 funcions

527
00:32:03,000 --> 00:32:06,000
no tenen idea del que els altres són variables locals.

528
00:32:06,000 --> 00:32:10,000
D'altra banda, aquí es diu int x = 5,

529
00:32:10,000 --> 00:32:12,000
i això està fora de l'abast de qualsevol funció.

530
00:32:12,000 --> 00:32:16,000
Està fora de l'abast de la principal, de manera que aquesta és una variable global.

531
00:32:16,000 --> 00:32:20,000
Això significa que dins d'aquestes 2 funcions quan dic x - x + + o

532
00:32:20,000 --> 00:32:26,000
Estic accedint a la mateixa de manera que aquest x i i això són variables diferents.

533
00:32:26,000 --> 00:32:30,000
Aquesta és la diferència entre una variable global i una variable local.

534
00:32:30,000 --> 00:32:33,000
Pel que fa a disseny es refereix, de vegades és probablement una millor idea

535
00:32:33,000 --> 00:32:37,000
per mantenir les variables locals sempre que sigui possible

536
00:32:37,000 --> 00:32:39,000
ja que tenir un munt de variables globals es pot tornar molt confús.

537
00:32:39,000 --> 00:32:42,000
Si vostè té un munt de funcions modificant tot la mateixa cosa

538
00:32:42,000 --> 00:32:45,000
és possible que oblidi el que si aquesta funció accidentalment modifica aquest mundial,

539
00:32:45,000 --> 00:32:47,000
i aquesta altra funció que no sap res d'ella,

540
00:32:47,000 --> 00:32:50,000
i que es posa bastant confús a mesura que més codi.

541
00:32:50,000 --> 00:32:53,000
Mantenir les variables locals sempre que sigui possible

542
00:32:53,000 --> 00:32:56,000
és només un bon disseny.

543
00:32:56,000 --> 00:33:00,000
Arrays, recordem, són simplement llistes d'elements del mateix tipus.

544
00:33:00,000 --> 00:33:04,000
Dins de CI no es pot tenir una llista com 1, 2,0, hola.

545
00:33:04,000 --> 00:33:06,000
No podem fer això.

546
00:33:06,000 --> 00:33:11,000
>> Quan es declara una matriu C en tots els elements han de ser del mateix tipus.

547
00:33:11,000 --> 00:33:14,000
Aquí tinc una matriu de 3 punts.

548
00:33:14,000 --> 00:33:18,000
Aquí tinc la longitud de la matriu, però si jo només ho estic declarant en aquesta sintaxi

549
00:33:18,000 --> 00:33:21,000
on puc especificar el que tots els elements són tècnicament jo no necessito això 3.

550
00:33:21,000 --> 00:33:25,000
El compilador és prou intel · ligent com per saber la mida de la matriu ha de ser.

551
00:33:25,000 --> 00:33:28,000
Ara quan vull obtenir o establir el valor d'una matriu

552
00:33:28,000 --> 00:33:30,000
aquesta és la sintaxi per fer-ho.

553
00:33:30,000 --> 00:33:33,000
En realitat, això modificarà el segon element de la matriu perquè, recordar,

554
00:33:33,000 --> 00:33:36,000
numeració comença en 0, no en 1.

555
00:33:36,000 --> 00:33:42,000
Si vull llegir aquest valor el que puc dir alguna cosa com int x = array [1].

556
00:33:42,000 --> 00:33:44,000
O si voleu establir aquest valor, com que estic fent aquí,

557
00:33:44,000 --> 00:33:47,000
Puc dir array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Que el temps per accedir als elements pel seu índex

559
00:33:50,000 --> 00:33:52,000
o la seva posició o on són a la matriu,

560
00:33:52,000 --> 00:33:57,000
i que la llista comença a 0.

561
00:33:57,000 --> 00:34:00,000
També podem tenir matrius de matrius,

562
00:34:00,000 --> 00:34:03,000
i això es diu una matriu multidimensional.

563
00:34:03,000 --> 00:34:05,000
Quan tenim una matriu multidimensional

564
00:34:05,000 --> 00:34:07,000
això vol dir que podem tenir alguna cosa com files i columnes,

565
00:34:07,000 --> 00:34:11,000
i això és només una forma de visualitzar això o pensar-hi.

566
00:34:11,000 --> 00:34:14,000
Quan tinc una matriu multidimensional que significa que vaig a començar a necessitar

567
00:34:14,000 --> 00:34:17,000
més d'un índex perquè si tinc una xarxa

568
00:34:17,000 --> 00:34:19,000
Només dic el que està a la fila no ens dóna un nombre.

569
00:34:19,000 --> 00:34:22,000
Això és realment només ens donarà una llista de nombres.

570
00:34:22,000 --> 00:34:25,000
Diguem que tinc aquesta sèrie aquí.

571
00:34:25,000 --> 00:34:30,000
Tinc una matriu anomenada quadrícula, i jo estic dient que és 2 files i 3 columnes,

572
00:34:30,000 --> 00:34:32,000
pel que aquesta és una forma de visualitzar.

573
00:34:32,000 --> 00:34:37,000
Quan dic que vull obtenir l'element en [1] [2]

574
00:34:37,000 --> 00:34:41,000
que vol dir que pel fet que aquestes són les files primera i després columnes

575
00:34:41,000 --> 00:34:44,000
Vaig a saltar a la fila 1 ja he dit 1.

576
00:34:44,000 --> 00:34:49,000
>> Llavors em vaig a venir aquí a la columna 2, i vaig a obtenir el valor 6.

577
00:34:49,000 --> 00:34:51,000
Té sentit?

578
00:34:51,000 --> 00:34:55,000
Multi-dimensionals, recordem, són tècnicament només un conjunt de matrius.

579
00:34:55,000 --> 00:34:57,000
Podem tenir arrays d'arrays d'arrays.

580
00:34:57,000 --> 00:35:00,000
Podem seguir endavant, però en realitat una forma de pensar

581
00:35:00,000 --> 00:35:03,000
com s'està exposat i el que passa és visualitzar

582
00:35:03,000 --> 00:35:09,000
en una xarxa com aquesta.

583
00:35:09,000 --> 00:35:12,000
En passar matrius a funcions, que van a comportar

584
00:35:12,000 --> 00:35:16,000
una mica diferent que quan passem variables regulars a les funcions

585
00:35:16,000 --> 00:35:18,000
com passar un int o un float.

586
00:35:18,000 --> 00:35:21,000
Quan passem a un tipus int o char o qualsevol d'aquests altres dades

587
00:35:21,000 --> 00:35:24,000
ens ho prenem una ullada a si la funció modifica

588
00:35:24,000 --> 00:35:28,000
el valor d'aquesta variable que el canvi no es va a propagar fins

589
00:35:28,000 --> 00:35:32,000
a la funció de trucada.

590
00:35:32,000 --> 00:35:35,000
Amb una matriu, d'altra banda, que passarà.

591
00:35:35,000 --> 00:35:39,000
Si pas en una matriu a una funció i que la funció canvia alguns dels elements,

592
00:35:39,000 --> 00:35:43,000
quan torni a la funció que es diu

593
00:35:43,000 --> 00:35:47,000
meva matriu ara serà diferent, i el vocabulari perquè

594
00:35:47,000 --> 00:35:50,000
és una matriu es passen per referència, com veurem més endavant.

595
00:35:50,000 --> 00:35:53,000
Això es relaciona amb com funcionen els punters, on aquests tipus de dades bàsiques,

596
00:35:53,000 --> 00:35:55,000
D'altra banda, es passen per valor.

597
00:35:55,000 --> 00:35:59,000
>> Podem pensar que a mesura que es fa una còpia d'una variable i després passar a la còpia.

598
00:35:59,000 --> 00:36:01,000
No importa el que fem amb aquesta variable.

599
00:36:01,000 --> 00:36:06,000
La funció de trucada no es donarà compte de que s'ha canviat.

600
00:36:06,000 --> 00:36:10,000
Les matrius són una mica diferents en aquest sentit.

601
00:36:10,000 --> 00:36:13,000
Per exemple, com acabem de veure, la principal és simplement una funció

602
00:36:13,000 --> 00:36:15,000
que pot prendre en dos arguments.

603
00:36:15,000 --> 00:36:20,000
El primer argument de la funció principal és argc, o el nombre d'arguments,

604
00:36:20,000 --> 00:36:23,000
i el segon argument es diu argv,

605
00:36:23,000 --> 00:36:27,000
i aquests són els valors reals d'aquests arguments.

606
00:36:27,000 --> 00:36:30,000
Diguem que tenen un programa anomenat this.c,

607
00:36:30,000 --> 00:36:34,000
i jo dic que això, i vaig a córrer això en la línia d'ordres.

608
00:36:34,000 --> 00:36:38,000
Ara, per passar alguns arguments per a mi programa que es diu això,

609
00:36:38,000 --> 00:36:42,000
Podria dir alguna cosa així com. / Això és cs 50.

610
00:36:42,000 --> 00:36:45,000
Això és el que ens imaginem a David a fer cada dia a la terminal.

611
00:36:45,000 --> 00:36:48,000
Però ara la funció principal dins d'aquest programa

612
00:36:48,000 --> 00:36:52,000
té aquests valors, de manera que argc és 4.

613
00:36:52,000 --> 00:36:56,000
Pot ser una mica confús perquè en realitat només estem passant és cs 50.

614
00:36:56,000 --> 00:36:58,000
Això és només 3.

615
00:36:58,000 --> 00:37:02,000
Però recorda que el primer element de argv o el primer argument

616
00:37:02,000 --> 00:37:05,000
és el nom de la funció en si.

617
00:37:05,000 --> 00:37:07,190
Així que això significa que hi ha 4 coses aquí,

618
00:37:07,190 --> 00:37:10,530
i el primer element serà. / aquest.

619
00:37:10,530 --> 00:37:12,970
I això es representa com una cadena.

620
00:37:12,970 --> 00:37:18,590
A continuació, els elements restants són el que va escriure en el després del nom del programa.

621
00:37:18,590 --> 00:37:22,720
Així que, en un apart, ja que és probable que vaig veure en pset 2,

622
00:37:22,720 --> 00:37:28,780
recordar que la cadena 50 és el nombre enter ≠ 50.

623
00:37:28,780 --> 00:37:32,520
Així que no podem dir alguna cosa com, 'int x = argv 3.

624
00:37:32,520 --> 00:37:36,470
>> Això no tindrà sentit, perquè això és una cadena, i aquest és un enter.

625
00:37:36,470 --> 00:37:38,510
Així que si vol convertir entre els dos, recorda, anem a

626
00:37:38,510 --> 00:37:40,810
té aquesta funció màgica anomenada atoi.

627
00:37:40,810 --> 00:37:46,270
Per això es necessita una cadena i retorna el sencer representat dins d'aquesta cadena.

628
00:37:46,270 --> 00:37:48,360
Així que això és un error fàcil de fer en el concurs,

629
00:37:48,360 --> 00:37:51,590
pensant que aquest serà automàticament el tipus correcte.

630
00:37:51,590 --> 00:37:53,860
Però només sé que aquests sempre seran cadenes

631
00:37:53,860 --> 00:38:00,920
encara que la cadena només conté un nombre enter o un caràcter o un flotador.

632
00:38:00,920 --> 00:38:03,380
Així que ara anem a parlar de temps d'execució.

633
00:38:03,380 --> 00:38:06,700
Quan tinguem tots aquests algoritmes que fan totes aquestes coses boges,

634
00:38:06,700 --> 00:38:11,580
es fa molt útil per fer la pregunta, "Quant de temps prendrà?"

635
00:38:11,580 --> 00:38:15,500
Representem a que, amb una cosa que es diu notació asimptòtica.

636
00:38:15,500 --> 00:38:18,430
Així que això significa que - bé, direm que li donem el nostre algorisme

637
00:38:18,430 --> 00:38:20,840
algunes entrades molt, molt, molt gran.

638
00:38:20,840 --> 00:38:23,840
Volem fer la pregunta, "Quant de temps prendrà?

639
00:38:23,840 --> 00:38:26,370
Quants passos es triga en el nostre algoritme per executar

640
00:38:26,370 --> 00:38:29,980
com una funció de la mida de l'entrada? "

641
00:38:29,980 --> 00:38:33,080
Així que la primera forma podem descriure el temps d'execució és de gran O.

642
00:38:33,080 --> 00:38:35,380
I aquest és el pitjor dels casos el temps de funcionament.

643
00:38:35,380 --> 00:38:38,590
Així que si volem ordenar una matriu, i donem el nostre algoritme d'una matriu

644
00:38:38,590 --> 00:38:41,000
això és en ordre descendent, quan hauria d'estar en ordre ascendent,

645
00:38:41,000 --> 00:38:43,130
que serà el pitjor dels casos.

646
00:38:43,130 --> 00:38:49,800
Aquest és el nostre límit superior de la durada màxima del temps del nostre algoritme prendrà.

647
00:38:49,800 --> 00:38:54,740
D'altra banda, aquest Ω es descriurà millor dels casos el temps de funcionament.

648
00:38:54,740 --> 00:38:58,210
Així que si li donem un arranjament ja està ordenat a un algoritme de classificació,

649
00:38:58,210 --> 00:39:00,940
Quant de temps es triga a resoldre?

650
00:39:00,940 --> 00:39:06,610
I això, a continuació, es descriu un límit inferior en temps d'execució.

651
00:39:06,610 --> 00:39:10,980
Així que aquí són només algunes paraules que descriuen alguns moments comuns de funcionament.

652
00:39:10,980 --> 00:39:13,120
Aquests són en ordre ascendent.

653
00:39:13,120 --> 00:39:16,060
El millor temps de funcionament que tenim es diu constant.

654
00:39:16,060 --> 00:39:19,800
>> Això vol dir que no importa quants elements donem el nostre algorisme,

655
00:39:19,800 --> 00:39:22,280
no importa el gran que és la nostra matriu, la seva classificació

656
00:39:22,280 --> 00:39:26,510
o fer el que estem fent a la matriu sempre tindrà la mateixa quantitat de temps.

657
00:39:26,510 --> 00:39:30,270
Per tant, pot representar que només amb un 1, que és una constant.

658
00:39:30,270 --> 00:39:32,410
També ens fixem en temps d'execució logarítmica.

659
00:39:32,410 --> 00:39:34,800
Així que alguna cosa com la recerca binària és logarítmica,

660
00:39:34,800 --> 00:39:37,140
on tallem el problema a la meitat cada vegada

661
00:39:37,140 --> 00:39:40,970
i llavors les coses només arribar més alt des d'allà.

662
00:39:40,970 --> 00:39:43,580
I si mai escriure una O de qualsevol algorisme factorial,

663
00:39:43,580 --> 00:39:47,850
és probable que no han de considerar això com el seu treball del dia.

664
00:39:47,850 --> 00:39:53,910
En comparar els temps d'execució, és important tenir en compte aquestes coses.

665
00:39:53,910 --> 00:39:57,760
Així que si tinc un algoritme que és O (n), i una altra persona

666
00:39:57,760 --> 00:40:03,590
té un algorisme de O (2n) són en realitat asimptòticament equivalent.

667
00:40:03,590 --> 00:40:06,590
Així que si ens imaginem n sigui un nombre gran com 111.000.000.000:

668
00:40:06,590 --> 00:40:13,090
així que quan estem comparant 111.000.000.000 a una mena de 111.000.000 + 3,

669
00:40:13,090 --> 00:40:17,640
que de sobte tres en realitat no fan una gran diferència ja.

670
00:40:17,640 --> 00:40:20,980
És per això que començarem a considerar aquestes coses com equivalents.

671
00:40:20,980 --> 00:40:24,220
Així que coses com aquestes constants aquí, hi ha 2 x això, o l'addició d'un 3,

672
00:40:24,220 --> 00:40:27,180
aquests són només constants, i aquests van a caure cap amunt.

673
00:40:27,180 --> 00:40:32,480
Així que per això tots els 3 d'aquests temps de funcionament són els mateixos que diuen que són O (n).

674
00:40:32,480 --> 00:40:37,490
De la mateixa manera, si tenim 2 temps d'execució altres, diguem O (n + 2n ³ ²), podem afegir

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, i després tenim un altre temps d'execució que és només O (³).

676
00:40:42,070 --> 00:40:46,290
de nou, es tracta del mateix, perquè aquests - aquests no són els mateixos.

677
00:40:46,290 --> 00:40:49,840
Aquestes són les coses mateixes, ho sento. Així que aquests són els mateixos perquè

678
00:40:49,840 --> 00:40:53,090
Aquest ³ va a dominar aquesta ² 2n.

679
00:40:53,090 --> 00:40:59,130
>> El que no és el mateix és que si se'ns ha acabat vegades com O (³) i O (n ²)

680
00:40:59,130 --> 00:41:02,820
perquè aquest ³ és molt més gran que aquesta ² n.

681
00:41:02,820 --> 00:41:05,470
Així que si tenim exponents, de sobte aquesta s'inicia a la matèria,

682
00:41:05,470 --> 00:41:08,280
però quan només estem tractant amb factors com estem aquí,

683
00:41:08,280 --> 00:41:12,810
llavors no va a importar, ja que només es va a abandonar.

684
00:41:12,810 --> 00:41:16,760
Fem una ullada a alguns dels algorismes que hem vist fins ara

685
00:41:16,760 --> 00:41:19,260
i parlar del seu temps d'execució.

686
00:41:19,260 --> 00:41:23,850
La primera manera de buscar un número en una llista, que vam veure, era la recerca lineal.

687
00:41:23,850 --> 00:41:26,950
I l'aplicació de cerca lineal és super senzill.

688
00:41:26,950 --> 00:41:30,490
Només tenim una llista, i anem a veure cada element de la llista

689
00:41:30,490 --> 00:41:34,260
fins trobar el nombre que busquem.

690
00:41:34,260 --> 00:41:38,370
Això significa que en el pitjor dels casos, aquest O (n).

691
00:41:38,370 --> 00:41:40,860
I el pitjor dels casos aquí podria ser si l'element està

692
00:41:40,860 --> 00:41:45,710
l'últim element, a continuació, utilitzant una recerca lineal que hem de mirar a cada element

693
00:41:45,710 --> 00:41:50,180
fins arribar a l'última amb la finalitat de saber que en realitat era a la llista.

694
00:41:50,180 --> 00:41:52,910
No podem abandonar a mig camí i dir: "Probablement no sigui allà".

695
00:41:52,910 --> 00:41:55,980
Amb la recerca lineal que hem de mirar a tot l'assumpte.

696
00:41:55,980 --> 00:41:59,090
El temps d'execució del millor cas, en canvi, és constant

697
00:41:59,090 --> 00:42:04,200
perquè en el millor dels casos l'element que estem buscant és només el primer de la llista.

698
00:42:04,200 --> 00:42:08,930
Així que va a portar exactament un pas, no importa el gran que la llista és

699
00:42:08,930 --> 00:42:12,140
si estem buscant el primer element cada vegada.

700
00:42:12,140 --> 00:42:15,390
>> Així que quan vostè busca, recordem, no es requereix que la llista estigui ordenada.

701
00:42:15,390 --> 00:42:19,430
Perquè estem simplement mirarà per sobre de cada element, i no importa realment

702
00:42:19,430 --> 00:42:23,560
quin ordre els elements es in

703
00:42:23,560 --> 00:42:28,110
Un algorisme de recerca més intel · ligent és una mena de recerca binària.

704
00:42:28,110 --> 00:42:31,500
Recordeu, l'aplicació de cerca binària és quan vostè va a

705
00:42:31,500 --> 00:42:34,320
seguir buscant a la meitat de la llista.

706
00:42:34,320 --> 00:42:38,000
I pel fet que està buscant en el medi, cal que la llista està ordenada

707
00:42:38,000 --> 00:42:40,580
o del que no sabem on el centre és, i hem de mirar per sobre de

708
00:42:40,580 --> 00:42:44,480
tota la llista per trobar-la, i llavors en aquest punt estem perdent el temps.

709
00:42:44,480 --> 00:42:48,480
Així que si tenim una llista ordenada i ens trobem amb el medi, anem a comparar el medi

710
00:42:48,480 --> 00:42:51,590
per l'element que estem buscant.

711
00:42:51,590 --> 00:42:54,640
Si és massa alt, llavors ens podem oblidar de la meitat dreta

712
00:42:54,640 --> 00:42:57,810
perquè sabem que si la nostra element ja és massa alt

713
00:42:57,810 --> 00:43:01,080
i tot a la dreta d'aquest element és encara més gran,

714
00:43:01,080 --> 00:43:02,760
llavors no cal mirar allà.

715
00:43:02,760 --> 00:43:05,430
Quan per contra, si el nostre element és massa baix,

716
00:43:05,430 --> 00:43:08,700
ho sabem tot a l'esquerra de l'element que també és massa baixa,

717
00:43:08,700 --> 00:43:11,390
pel que no té gaire sentit mirar allà, tampoc.

718
00:43:11,390 --> 00:43:15,760
D'aquesta manera, amb cada pas i cada vegada que ens fixem en el punt mig de la llista,

719
00:43:15,760 --> 00:43:19,060
anem a reduir el nostre problema a la meitat perquè de sobte sabem

720
00:43:19,060 --> 00:43:23,040
un munt de nombres que no poden ser la que estem buscant.

721
00:43:23,040 --> 00:43:26,950
>> En aquest pseudocodi seria alguna cosa com això,

722
00:43:26,950 --> 00:43:30,990
i perquè estem tallant la llista per la meitat cada vegada,

723
00:43:30,990 --> 00:43:34,920
nostres pitjors salts de temps d'execució de lineal a logarítmica.

724
00:43:34,920 --> 00:43:39,260
Així que de sobte es té log-in passos per tal de trobar un element en una llista.

725
00:43:39,260 --> 00:43:42,460
El temps d'execució millor dels casos, però, continua sent constant

726
00:43:42,460 --> 00:43:45,180
perquè ara, anem a dir que l'element que estem buscant és

727
00:43:45,180 --> 00:43:48,380
sempre el centre exacte de la llista original.

728
00:43:48,380 --> 00:43:52,080
Així que podem fer créixer la nostra llista tan gran com vulguem, però si l'element que estem buscant és al mig,

729
00:43:52,080 --> 00:43:54,910
llavors només va a portar un pas.

730
00:43:54,910 --> 00:44:00,920
Així que per això estem O (log n) i Ω (1) o constant.

731
00:44:00,920 --> 00:44:04,510
Anem a executar realment la recerca binària en aquesta llista.

732
00:44:04,510 --> 00:44:08,020
Així que diguem que estem buscant l'element 164.

733
00:44:08,020 --> 00:44:11,650
El primer que farem és trobar el punt mitjà d'aquesta llista.

734
00:44:11,650 --> 00:44:15,060
El que passa és que el punt mitjà es va a caure enmig d'aquests dos nombres,

735
00:44:15,060 --> 00:44:18,960
així que anem a dir arbitràriament, cada vegada que el punt mitjà se situa entre dos nombres,

736
00:44:18,960 --> 00:44:21,150
anem a reunir.

737
00:44:21,150 --> 00:44:24,330
Només hem de assegurar-nos que fem això cada pas del camí.

738
00:44:24,330 --> 00:44:29,040
Així que ens anem a reunir i direm que 161 és el centre de la nostra llista.

739
00:44:29,040 --> 00:44:34,640
Així 161 <164, i cada element a l'esquerra de 161

740
00:44:34,640 --> 00:44:39,120
També és <164, pel que sabem que no ens ajudarà en absolut

741
00:44:39,120 --> 00:44:42,690
per començar a buscar per aquí perquè l'element que estem buscant no pot ser-hi.

742
00:44:42,690 --> 00:44:47,060
Així que el que podem fer és simplement podem oblidar que la meitat de tota l'esquerra de la llista,

743
00:44:47,060 --> 00:44:51,700
i ara només tenen en compte des de la dreta de la dècada de 161.

744
00:44:51,700 --> 00:44:54,050
>> Així que de nou, aquest és el punt mig, anem a arrodonir.

745
00:44:54,050 --> 00:44:56,260
Ara 175 és massa gran.

746
00:44:56,260 --> 00:44:59,180
Així que sabem que no ens ajudarà a buscar aquí o aquí,

747
00:44:59,180 --> 00:45:06,610
de manera que només es pot tirar això, i al final ens va a colpejar el 164.

748
00:45:06,610 --> 00:45:10,560
Qualsevol pregunta sobre la recerca binària?

749
00:45:10,560 --> 00:45:14,180
Anem a passar de buscar a través d'una llista ja ordenada-

750
00:45:14,180 --> 00:45:17,660
per realment tenint una llista de nombres en qualsevol ordre

751
00:45:17,660 --> 00:45:20,960
i fer que la llista en ordre ascendent.

752
00:45:20,960 --> 00:45:24,060
El primer algoritme vam veure va ser anomenat tipus bombolla.

753
00:45:24,060 --> 00:45:27,300
I això seria més simple dels algoritmes que vam veure.

754
00:45:27,300 --> 00:45:32,970
Ordenament de bombolla, diu que quan qualsevol dels 2 elements dins de la llista estan fora de lloc,

755
00:45:32,970 --> 00:45:36,500
és a dir, hi ha un nombre superior a l'esquerra d'un nombre més baix,

756
00:45:36,500 --> 00:45:40,190
llavors canviarem, perquè això vol dir que la llista serà

757
00:45:40,190 --> 00:45:42,860
"Més ordenada" del que era abans.

758
00:45:42,860 --> 00:45:45,180
I només continuarem amb aquest procés una i altra vegada i una altra

759
00:45:45,180 --> 00:45:52,100
fins que, finalment, el tipus d'elements bombolla a la seva ubicació correcta i tenim una llista ordenada.

760
00:45:52,100 --> 00:45:57,230
>> El temps d'execució que això serà O (n ²). Per què?

761
00:45:57,230 --> 00:46:00,370
Bé, doncs en el pitjor dels casos, prendrem cada element, i

762
00:46:00,370 --> 00:46:04,570
anem a acabar comparant amb qualsevol altre element a la llista.

763
00:46:04,570 --> 00:46:08,030
Però en el millor dels casos, tenim una llista ja ordenada, bombolla tipus de

764
00:46:08,030 --> 00:46:12,230
només passarà per una vegada, digui "Nope. Jo no vaig fer cap swaps, així que he acabat."

765
00:46:12,230 --> 00:46:17,410
Així que tenim un temps millor dels casos el funcionament de Ω (n).

766
00:46:17,410 --> 00:46:20,680
Anem a córrer espècie de bombolla en una llista.

767
00:46:20,680 --> 00:46:23,560
O anem a mirar alguns pseudocodi molt ràpid.

768
00:46:23,560 --> 00:46:28,160
Volem dir que volem perdre de vista, en cada iteració del bucle,

769
00:46:28,160 --> 00:46:32,190
fer un seguiment de si podem o no canviar cap element.

770
00:46:32,190 --> 00:46:37,610
Així que la raó d'això és, que anem a parar quan no hem canviat cap element.

771
00:46:37,610 --> 00:46:41,980
Així que al principi del nostre bucle no hem canviat res, així que vaig a dir que és fals.

772
00:46:41,980 --> 00:46:47,170
Ara, anirem per la llista i comparar element a element i i + 1

773
00:46:47,170 --> 00:46:50,310
i si és el cas que hi ha un nombre més gran a l'esquerra d'un nombre més petit,

774
00:46:50,310 --> 00:46:52,310
llavors només anem a intercanviar-les.

775
00:46:52,310 --> 00:46:54,490
>> I després recordarem que ens canviat un element.

776
00:46:54,490 --> 00:46:58,900
Això vol dir que hem de passar per la llista almenys una vegada més

777
00:46:58,900 --> 00:47:02,160
perquè la condició en què es deté quan tota la llista ja està ordenada,

778
00:47:02,160 --> 00:47:04,890
el que significa que no han fet cap swaps.

779
00:47:04,890 --> 00:47:09,960
Així que per això la nostra condició aquí és ", mentre que alguns elements han estat canviats.

780
00:47:09,960 --> 00:47:13,720
Així que ara anem a veure això que s'executa en una llista.

781
00:47:13,720 --> 00:47:16,640
Tinc la llista 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Ordenament de bombolla començarà tot el camí a l'esquerra, i va a comparar

783
00:47:19,850 --> 00:47:24,700
Els elements que, de manera 0 a i + 1, que és l'element 1.

784
00:47:24,700 --> 00:47:29,020
Va a dir, bé 5> 0, però en aquest moment 5 és a l'esquerra,

785
00:47:29,020 --> 00:47:32,500
així que he de canviar el 5 i el 0.

786
00:47:32,500 --> 00:47:35,470
Quan els intercanviar, de sobte em surt aquest llista diferent.

787
00:47:35,470 --> 00:47:38,260
Ara 5> 1, de manera que anem a intercanviar-les.

788
00:47:38,260 --> 00:47:42,160
5 no és> 6, de manera que no ha de fer res aquí.

789
00:47:42,160 --> 00:47:46,690
Però 6> 4, de manera que hem de canviar.

790
00:47:46,690 --> 00:47:49,740
Un cop més, hem de repassar la llista sencera per descobrir finalment

791
00:47:49,740 --> 00:47:52,330
que aquestes estan fora de servei, ens canviar,

792
00:47:52,330 --> 00:47:57,120
i en aquest moment hem de passar per la llista 1 hora més

793
00:47:57,120 --> 00:48:05,390
per assegurar-se que tot és al seu ordre, i en aquest tipus bombolla punt ha acabat.

794
00:48:05,390 --> 00:48:10,720
Un algorisme diferent per prendre alguns elements i ordenar-és una mena de selecció.

795
00:48:10,720 --> 00:48:15,740
La idea darrere d'ordenació per selecció és que construirem una part ordenada de la llista

796
00:48:15,740 --> 00:48:18,150
1 element alhora.

797
00:48:18,150 --> 00:48:23,170
>> I la manera com ho farem és construint el segment esquerre de la llista.

798
00:48:23,170 --> 00:48:27,510
I en el fons, tots - a cada pas, tindrem el més mínim element que ens queda

799
00:48:27,510 --> 00:48:32,310
que no ha estat encara ordenat, i ens mourem en aquest segment ordenada.

800
00:48:32,310 --> 00:48:35,850
Això vol dir que hem de trobar contínuament l'element mínim sense classificar

801
00:48:35,850 --> 00:48:40,720
i després prendre aquest element mínim i intercanviar amb el

802
00:48:40,720 --> 00:48:45,090
va deixar a la majoria d'elements que no està ordenada.

803
00:48:45,090 --> 00:48:50,890
El temps d'execució que això serà O (n ²) perquè en el pitjor dels casos

804
00:48:50,890 --> 00:48:55,070
hem de comparar cada element a tots els altres elements.

805
00:48:55,070 --> 00:48:59,250
Com que estem dient que si comencem a la meitat esquerra de la llista, cal

806
00:48:59,250 --> 00:49:02,970
anar a través de tot el segment dret per trobar l'element més petit.

807
00:49:02,970 --> 00:49:05,430
I llavors, de nou, hem d'anar sobre el segment de la dreta i tot

808
00:49:05,430 --> 00:49:08,210
seguir repetint una i altra i una altra.

809
00:49:08,210 --> 00:49:11,350
Això serà ² n. Anem a necessitar un llaç per l'interior d'un altre bucle for

810
00:49:11,350 --> 00:49:13,350
el que suggereix ² n.

811
00:49:13,350 --> 00:49:16,530
En el pensament millor dels casos, direm que li donem una llista ja ordenada;

812
00:49:16,530 --> 00:49:19,270
que en realitat no fan res millor que ² n.

813
00:49:19,270 --> 00:49:21,730
Per tipus de selecció no té manera de saber que

814
00:49:21,730 --> 00:49:25,540
l'element mínim és el que succeeix a mirar.

815
00:49:25,540 --> 00:49:28,970
Encara necessita per assegurar-se que això és realment mínim.

816
00:49:28,970 --> 00:49:31,670
>> I l'única manera d'assegurar-se que és el mínim, utilitzant aquest algorisme,

817
00:49:31,670 --> 00:49:34,640
és mirar cada element nou.

818
00:49:34,640 --> 00:49:38,420
Així que en realitat, si li donen - si se li dóna una llista d'ordenació per selecció ja classificada,

819
00:49:38,420 --> 00:49:42,720
que no farà res millor que donar-li una llista que no està ordenada encara.

820
00:49:42,720 --> 00:49:46,320
Per cert, si passa a ser el cas de que alguna cosa és O (alguna cosa)

821
00:49:46,320 --> 00:49:50,640
i l'omega d'alguna cosa, només puc dir més breument que és θ d'alguna cosa.

822
00:49:50,640 --> 00:49:52,760
Així que si veus que sorgeixen arreu, això és el que això significa.

823
00:49:52,760 --> 00:49:57,580
>> Si alguna cosa és theta de ² n, és alhora gran O (n ²) i Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Així que el millor i el pitjor cas, no fa cap diferència,

825
00:49:59,790 --> 00:50:04,400
l'algorisme es farà la mateixa cosa cada vegada.

826
00:50:04,400 --> 00:50:06,610
Així que això és el que pseudocodi per ordenar selecció podria ser similar.

827
00:50:06,610 --> 00:50:10,630
Estem bàsicament dirà que vull per iterar sobre la llista

828
00:50:10,630 --> 00:50:15,180
d'esquerra a dreta, i en cada iteració del bucle, vaig a moure

829
00:50:15,180 --> 00:50:19,780
l'element mínim en aquesta porció de la llista ordenada.

830
00:50:19,780 --> 00:50:23,260
I una vegada que em moc una mica allà, no he de mirar a aquest element nou.

831
00:50:23,260 --> 00:50:28,600
Perquè tan aviat com canviar un element en el segment esquerre de la llista, s'ordenen

832
00:50:28,600 --> 00:50:32,600
perquè estem fent tot en ordre ascendent utilitzant mínims.

833
00:50:32,600 --> 00:50:38,740
Llavors vam dir, bé, estem en la posició i, i hem de mirar tots els elements

834
00:50:38,740 --> 00:50:42,260
a la dreta de i per tal de trobar el mínim.

835
00:50:42,260 --> 00:50:46,150
Així que això significa que volem mirar des i + 1 fins al final de la llista.

836
00:50:46,150 --> 00:50:51,610
I ara, si l'element que estem mirant és menor que el nostre mínim fins ara,

837
00:50:51,610 --> 00:50:54,190
que, recordem, estem començant el descompte mínim per ser just

838
00:50:54,190 --> 00:50:57,020
qualsevol element que estem actualment, vaig a assumir que és el mínim.

839
00:50:57,020 --> 00:51:00,270
Si trobo un element que és més petit que això, llavors jo vaig a dir, bé,

840
00:51:00,270 --> 00:51:02,700
Bé, he trobat un nou mínim.

841
00:51:02,700 --> 00:51:06,080
Vaig a recordar on era aquest mínim.

842
00:51:06,080 --> 00:51:09,560
>> Així que ara, un cop passat per aquest segment sense classificar dret,

843
00:51:09,560 --> 00:51:16,690
Puc dir que canviaré l'element mínim amb l'element que es troba en la posició i.

844
00:51:16,690 --> 00:51:21,100
Això va a construir la meva llista, la meva porció ordenada de la llista d'esquerra a dreta,

845
00:51:21,100 --> 00:51:25,190
i no alguna vegada ha de veure un element de nou una vegada que estigui en aquesta part.

846
00:51:25,190 --> 00:51:27,930
Quan l'hem canviat.

847
00:51:27,930 --> 00:51:30,260
Així que anem a executar l'ordenació per selecció en aquesta llista.

848
00:51:30,260 --> 00:51:38,220
L'element blau aquí serà la i, i l'element vermell serà l'element mínim.

849
00:51:38,220 --> 00:51:41,570
Així que comença tot el camí a l'esquerra de la llista, com a mínim 5.

850
00:51:41,570 --> 00:51:44,610
Ara hem de trobar l'element Unsorted mínim.

851
00:51:44,610 --> 00:51:49,480
Per això diem 0 <5, de manera que 0 és el meu nou mínim.

852
00:51:49,480 --> 00:51:53,820
>> Però no pot quedar-se aquí, perquè encara podem reconèixer que 0 és el més petit,

853
00:51:53,820 --> 00:51:59,390
hem de passar per tots els altres elements de la llista per assegurar-se.

854
00:51:59,390 --> 00:52:01,760
Així 1 és més gran, és més gran 6, 4 és més gran.

855
00:52:01,760 --> 00:52:05,850
Això vol dir que després de veure tots aquests elements, he determinat 0 és el més petit.

856
00:52:05,850 --> 00:52:09,800
Així que canviaré el 5 i el 0.

857
00:52:09,800 --> 00:52:15,480
Quan canviï això, em vaig a posar una nova llista, i sé que mai he de mirar en aquest 0 de nou

858
00:52:15,480 --> 00:52:19,380
perquè una vegada que ho he canviat, ho he classificat i ja està.

859
00:52:19,380 --> 00:52:22,730
Ara dóna la casualitat que l'element blau torna a ser el 5,

860
00:52:22,730 --> 00:52:26,030
i hem de mirar a la 1, la 6 i la 4 per determinar que una

861
00:52:26,030 --> 00:52:31,520
És l'element més petit de menys, així que anem a canviar l'1 i el 5.

862
00:52:31,520 --> 00:52:36,890
Un cop més, hem de mirar - comparar el 5 i el 6 i el 4,

863
00:52:36,890 --> 00:52:39,830
i canviarem el 4 i el 5, i, finalment, comparar,

864
00:52:39,830 --> 00:52:45,740
aquests 2 nombres i intercanviar fins que tinguem la nostra llista ordenada.

865
00:52:45,740 --> 00:52:49,730
Qualsevol pregunta sobre tipus de selecció?

866
00:52:49,730 --> 00:52:56,420
Bé. Passem a l'últim tema aquí, i que és la recursivitat.

867
00:52:56,420 --> 00:52:59,810
>> La recursivitat, recordi, és aquesta cosa meta realment on una funció

868
00:52:59,810 --> 00:53:02,740
repetidament es diu.

869
00:53:02,740 --> 00:53:05,620
Llavors, en algun moment, mentre que el nostre succió en repetides ocasions que es fa dir,

870
00:53:05,620 --> 00:53:10,100
ha d'haver algun punt en què vam deixar de dir.

871
00:53:10,100 --> 00:53:13,670
Perquè si no fem això, llavors només seguirem fent això per sempre,

872
00:53:13,670 --> 00:53:16,660
i el nostre programa no només va a acabar.

873
00:53:16,660 --> 00:53:19,200
Cridem a aquesta condició, el cas base.

874
00:53:19,200 --> 00:53:22,570
I el cas base, diu, en lloc de cridar a una funció més,

875
00:53:22,570 --> 00:53:25,330
Només vaig a tornar algun valor.

876
00:53:25,330 --> 00:53:28,080
Així que una vegada que hem retornat un valor, hem deixat de cridar a nosaltres mateixos,

877
00:53:28,080 --> 00:53:32,550
i la resta de les trucades que hem fet fins ara també poden tornar.

878
00:53:32,550 --> 00:53:36,050
El contrari de la hipòtesi de base és el cas recursiu.

879
00:53:36,050 --> 00:53:39,050
I aquí és quan volem fer una altra crida a la funció que es troba,

880
00:53:39,050 --> 00:53:44,690
I és probable que, encara que no sempre, es vol utilitzar diferents arguments.

881
00:53:44,690 --> 00:53:48,940
>> Així que si tenim una funció anomenada f, i f acaba de cridar a prendre un argument,

882
00:53:48,940 --> 00:53:52,010
i ens segueixen trucant f (1), f (1), f (1), i dóna la casualitat que

883
00:53:52,010 --> 00:53:56,510
l'argument cau en un cas recursiu, estem encara mai va a parar.

884
00:53:56,510 --> 00:54:01,620
Fins i tot si tenim un cas base, cal assegurar-se que a la llarga ens va a colpejar aquest cas base.

885
00:54:01,620 --> 00:54:04,250
No ens limitem a seguir romanent en aquest cas recursiu.

886
00:54:04,250 --> 00:54:09,870
En general, quan ens truqui, nosaltres probablement tindrem un argument diferent cada vegada.

887
00:54:09,870 --> 00:54:12,700
Heus aquí una funció recursiva realment simple.

888
00:54:12,700 --> 00:54:15,090
Així que això va a calcular el factorial d'un nombre.

889
00:54:15,090 --> 00:54:17,790
A sobre de la tapa aquí tenim al nostre cas base.

890
00:54:17,790 --> 00:54:22,330
En el cas que n ≤ 1, no anem a trucar a factorial de nou.

891
00:54:22,330 --> 00:54:26,490
Anem a parar, només tornarem algun valor.

892
00:54:26,490 --> 00:54:30,170
Si no fos així, llavors anem a colpejar nostre cas recursiu.

893
00:54:30,170 --> 00:54:33,550
Noteu aquí que no només estem trucant factorial (n), perquè això no seria molt útil.

894
00:54:33,550 --> 00:54:36,810
Anem a trucar a factorial de res més.

895
00:54:36,810 --> 00:54:40,850
>> I perquè pugui veure, amb el temps si passem una mica factorial (5) o,

896
00:54:40,850 --> 00:54:45,900
anomenarem a factorial (4) i així successivament, i al final ens va a colpejar aquest cas base.

897
00:54:45,900 --> 00:54:51,730
Així que això té bona pinta. Anem a veure què passa quan realment executar aquest.

898
00:54:51,730 --> 00:54:57,840
Es tracta de la pila, i diguem que principal dirà a aquesta funció amb un argument (4).

899
00:54:57,840 --> 00:55:02,200
Així que un cop factorial veu i = 4, factorial es dirà.

900
00:55:02,200 --> 00:55:05,010
Ara, de sobte, tenim factorial (3).

901
00:55:05,010 --> 00:55:10,780
Així doncs, aquestes funcions es seguirà creixent fins que finalment arribem al nostre cas base.

902
00:55:10,780 --> 00:55:17,830
En aquest punt, el valor de retorn d'això és el retorn (nx el valor de retorn d'aquesta),

903
00:55:17,830 --> 00:55:21,290
el valor de retorn d'aquesta nx és el valor de retorn d'aquesta.

904
00:55:21,290 --> 00:55:23,290
Finalment, hem d'arribar a algun nombre.

905
00:55:23,290 --> 00:55:26,560
A la part superior aquí, diem return 1.

906
00:55:26,560 --> 00:55:30,650
Això significa que una vegada que torni a aquest nombre, que pot fer esclatar est de la pila.

907
00:55:30,650 --> 00:55:36,570
Així que aquest factorial (1) està fet.

908
00:55:36,570 --> 00:55:41,190
Quan un torna, aquesta factorials (1) devolucions, aquest retorn a 1.

909
00:55:41,190 --> 00:55:46,910
El valor de retorn d'aquesta, recordem, era nx el valor de retorn d'aquesta.

910
00:55:46,910 --> 00:55:50,720
Llavors, de sobte, aquest home sap que vull tornar 2.

911
00:55:50,720 --> 00:55:55,910
>> Així que recorda, tornar el valor d'això és només el valor de retorn nx aquí.

912
00:55:55,910 --> 00:56:01,160
Així que ara podem dir 3 x 2, i, finalment, aquí podem dir

913
00:56:01,160 --> 00:56:04,010
això serà de 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
I una vegada que això torni, ens posem mans a un sol nombre enter dins del principal.

915
00:56:09,570 --> 00:56:15,460
Teniu alguna pregunta respecte la recursivitat?

916
00:56:15,460 --> 00:56:17,090
Està bé. Així que no hi ha més temps per preguntes al final,

917
00:56:17,090 --> 00:56:23,360
però ara Joseph cobrirà els temes restants.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] D'acord. Així que ara que hem parlat de recurrències,

919
00:56:25,590 --> 00:56:27,840
anem a parlar una mica sobre el que merge sort és.

920
00:56:27,840 --> 00:56:31,740
Combinar tipus és bàsicament una altra manera d'ordenar una llista de nombres.

921
00:56:31,740 --> 00:56:36,430
I la manera com funciona és, amb una mena de barreja té una llista, i és el que fem

922
00:56:36,430 --> 00:56:39,120
diem, anem a dividir-la en dues meitats.

923
00:56:39,120 --> 00:56:42,750
En primer lloc, es quedarà sense fondre de nou tipus a la meitat esquerra,

924
00:56:42,750 --> 00:56:45,040
llavors anem a córrer merge sort en la meitat dreta,

925
00:56:45,040 --> 00:56:50,240
i això ens dóna ara dues meitats que s'ordenen, i ara anem a combinar les meitats.

926
00:56:50,240 --> 00:56:55,010
És una mica difícil de veure sense un exemple, així que seguirem tot el procediment i veure què passa.

927
00:56:55,010 --> 00:56:59,590
Així que començar amb aquesta llista, l'hi divideix en dues meitats.

928
00:56:59,590 --> 00:57:02,300
Correm merge sort en la meitat esquerra primer.

929
00:57:02,300 --> 00:57:06,660
Així que aquesta és la meitat esquerra, i ara executa a través d'aquesta llista de nou

930
00:57:06,660 --> 00:57:09,800
que es passa a una mena de barreja, i després ens veiem, de nou,

931
00:57:09,800 --> 00:57:13,270
a la banda esquerra d'aquesta llista i es corre fusionar tipus sobre el mateix.

932
00:57:13,270 --> 00:57:15,880
Ara, ens posem mans a una llista de números 2,

933
00:57:15,880 --> 00:57:19,010
i ara la meitat esquerra és només un element de llarg, i no podem

934
00:57:19,010 --> 00:57:23,380
dividir una llista que és només un element en la meitat, pel que acaba de dir, una vegada que tinguem 50,

935
00:57:23,380 --> 00:57:26,400
que és només un element, ja està solucionat.

936
00:57:26,400 --> 00:57:29,860
>> Un cop hàgim acabat amb això, podem veure que podem

937
00:57:29,860 --> 00:57:32,230
passar a la part dreta d'aquesta llista,

938
00:57:32,230 --> 00:57:36,480
i 3 també es classifiquen, de manera que ara que les dues meitats d'aquesta llista estan ordenades

939
00:57:36,480 --> 00:57:39,080
podem unir aquests números de nou junts.

940
00:57:39,080 --> 00:57:45,320
Així que veiem 50 i 3; 3 és inferior a 50, el que va en primer lloc i després 50 entra

941
00:57:45,320 --> 00:57:49,340
Ara, això està fet, tornem a aquesta llista i ordenar és la meitat dreta.

942
00:57:49,340 --> 00:57:52,440
42 és el seu propi nombre, així que ja ordenats.

943
00:57:52,440 --> 00:57:57,850
Així que ara comparem aquests 2 i 3 és menor que 42, per la qual cosa es va posar en primer lloc,

944
00:57:57,850 --> 00:58:02,340
ara de 42 anys es va posar en, i el 50 es posa endins

945
00:58:02,340 --> 00:58:07,220
Ara, que està classificat, anem tot el camí fins al cim, 1337 i 15.

946
00:58:07,220 --> 00:58:14,560
Bé, ara ens fixem en la part esquerra d'aquesta llista; 1337 és per si mateix el que és ordenat i el mateix amb 15.

947
00:58:14,560 --> 00:58:19,020
Així que ara combinem aquests dos nombres per ordenar la llista original, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
el que va en primer lloc, a continuació, va in 1337

949
00:58:23,060 --> 00:58:26,640
I ara ens ordenen les dues meitats de la llista original fins a la part superior.

950
00:58:26,640 --> 00:58:30,440
I tot el que has de fer és combinar aquests.

951
00:58:30,440 --> 00:58:36,890
Ens fixem en els 2 primers números d'aquesta llista, 3 <15, per la qual cosa entra en la matriu primer ordenar.

952
00:58:36,890 --> 00:58:44,460
15 <42, així que va polz Ara, 42 <1337, que va in

953
00:58:44,460 --> 00:58:51,010
50 <1337, per la qual cosa va in I noti que només va trigar 2 nombres fora d'aquesta llista.

954
00:58:51,010 --> 00:58:53,640
Així que no només estem alternant entre les dues llistes.

955
00:58:53,640 --> 00:58:56,050
Estem veient el principi, i estem prenent l'element

956
00:58:56,050 --> 00:59:00,270
que és més petit i després posar-lo en la nostra matriu.

957
00:59:00,270 --> 00:59:04,080
Ara hem fusionat tots les meitats i ja està.

958
00:59:04,080 --> 00:59:07,780
>> Qualsevol pregunta sobre fusionar tipus? Sí?

959
00:59:07,780 --> 00:59:14,190
[Estudiant] Si es tracta de dividir en grups diferents, per què no acaba de dividir una vegada

960
00:59:14,190 --> 00:59:19,970
i té 3 i 2 en un grup? [Resta pregunta inintel · ligible]

961
00:59:19,970 --> 00:59:24,940
La raó - de manera que la pregunta és, per què no podem simplement combinar-los en aquest primer pas després que els tenim?

962
00:59:24,940 --> 00:59:29,530
La raó per la qual podem fer això, comenci en els elements d'esquerra-la majoria de les dues parts,

963
00:59:29,530 --> 00:59:33,040
i després prendre la més petita i la va posar dins, és que sabem que aquests

964
00:59:33,040 --> 00:59:35,290
llistes individuals de les comandes ordenats.

965
00:59:35,290 --> 00:59:37,290
Així que si estic mirant als elements més a l'esquerra de les dues meitats,

966
00:59:37,290 --> 00:59:40,490
Jo sé que seran els elements més petits d'aquestes llistes.

967
00:59:40,490 --> 00:59:43,930
Així que puc posar-los en els llocs més petits elements d'aquesta llarga llista.

968
00:59:43,930 --> 00:59:47,810
D'altra banda, si miro aquests dos llistes en el segon nivell d'allà,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 i 15, els que no estan ordenades.

970
00:59:51,640 --> 00:59:55,770
Així que si miro als 50 i 1337, em vaig a posar 50 en la meva primera llista.

971
00:59:55,770 --> 01:00:00,130
Però això no té molt sentit, ja que 3 és l'element més petit de tots ells.

972
01:00:00,130 --> 01:00:04,390
Així que l'única raó per la qual podem fer aquest pas es deu a la combinació de les nostres llistes ja estan ordenats.

973
01:00:04,390 --> 01:00:07,010
És per això que hem de baixar tot el camí fins al fons

974
01:00:07,010 --> 01:00:09,800
perquè quan tenim un sol nombre, vostè sap que un sol nombre

975
01:00:09,800 --> 01:00:14,120
en i de per si ja és una llista ordenada.

976
01:00:14,120 --> 01:00:19,360
>> Alguna pregunta? No?

977
01:00:19,360 --> 01:00:24,260
Complexitat? Bé, es pot veure que en cada pas hi ha números finals,

978
01:00:24,260 --> 01:00:27,590
i podem dividir una llista en el registre mitjà n vegades,

979
01:00:27,590 --> 01:00:31,700
que és d'on s'obté aquest log n x n complexitat.

980
01:00:31,700 --> 01:00:34,940
I veuràs el millor dels casos per tipus de combinació és n log n, i que només succeeix així

981
01:00:34,940 --> 01:00:39,340
que el pitjor dels casos, o la Ω enllà, també és n log n.

982
01:00:39,340 --> 01:00:42,480
Una cosa a tenir en compte.

983
01:00:42,480 --> 01:00:45,750
Canviant de tema, anirem a algun arxiu de súper bàsic I / O.

984
01:00:45,750 --> 01:00:48,830
Si es mirava a Scramble, t'adonaràs que tenia algun tipus de sistema

985
01:00:48,830 --> 01:00:51,270
on es pot escriure en un arxiu de registre si vostè llegeix a través del codi.

986
01:00:51,270 --> 01:00:53,730
Anem a veure com es pot fer això.

987
01:00:53,730 --> 01:00:57,450
Bé, tenim fprintf, que es pot considerar com just printf,

988
01:00:57,450 --> 01:01:01,720
però només imprimir a un fitxer en comptes, i per tant la f al principi.

989
01:01:01,720 --> 01:01:07,570
Aquest tipus de codi fins aquí, el que fa és, com hauràs vist en Scramble,

990
01:01:07,570 --> 01:01:12,310
passa a través de la impressió matriu 2-dimensional fora fila per fila quins són els números.

991
01:01:12,310 --> 01:01:17,850
En aquest cas, printf imprimeix al seu terminal o el que anomenem la sortida estàndard de secció.

992
01:01:17,850 --> 01:01:22,170
>> I ara, en aquest cas, l'únic que has de fer és reemplaçar printf amb fprintf,

993
01:01:22,170 --> 01:01:26,770
diuen que sobre el fitxer que voleu imprimir i, en aquest cas, només s'imprimeix a aquest arxiu

994
01:01:26,770 --> 01:01:32,230
en lloc d'això imprimint al seu terminal.

995
01:01:32,230 --> 01:01:36,500
Bé, llavors això ens porta a la pregunta: D'on traiem aquest tipus de fitxer des, oi?

996
01:01:36,500 --> 01:01:39,840
Passem vos per aquest fuction de fprintf, però no teníem idea d'on vi.

997
01:01:39,840 --> 01:01:43,980
Bé, al principi del codi, el que vam tenir va ser aquest fragment de codi per aquí,

998
01:01:43,980 --> 01:01:48,340
que bàsicament diu que es pot obrir el fitxer log.txt flama.

999
01:01:48,340 --> 01:01:53,220
Què fem després d'això és que hem d'assegurar que l'arxiu està realment obert amb èxit.

1000
01:01:53,220 --> 01:01:57,070
Així que pot fallar per múltiples raons, vostè no té prou espai al seu ordinador, per exemple.

1001
01:01:57,070 --> 01:01:59,790
Així que sempre és important abans de fer qualsevol operació amb l'arxiu

1002
01:01:59,790 --> 01:02:03,300
que comprovem si aquest arxiu es va obrir correctament.

1003
01:02:03,300 --> 01:02:09,330
Així que el que a, aquest és un argument a fopen, bé, pot obrir un arxiu de moltes maneres.

1004
01:02:09,330 --> 01:02:13,510
El que podem fer és que l'hi pot transmetre w, el que significa reemplaçar l'arxiu si surt ja,

1005
01:02:13,510 --> 01:02:18,070
Podem passar una a, afegir al final de l'arxiu en lloc que sigui redefinit,

1006
01:02:18,070 --> 01:02:22,730
o podem especificar r, és a dir, anem a obrir l'arxiu com de només lectura.

1007
01:02:22,730 --> 01:02:24,890
Així que si el programa intenta fer canvis a l'arxiu,

1008
01:02:24,890 --> 01:02:30,140
cridar en ells i no deixis que ho facin.

1009
01:02:30,140 --> 01:02:33,320
Finalment, un cop que hàgim acabat amb l'arxiu, feta realitzar operacions en ell,

1010
01:02:33,320 --> 01:02:35,860
hem d'assegurar que tanqui l'arxiu.

1011
01:02:35,860 --> 01:02:38,830
I així, al final del seu programa, que passarà de nou

1012
01:02:38,830 --> 01:02:42,120
l'arxiu que ha obert, i simplement tancar-la.

1013
01:02:42,120 --> 01:02:44,650
Així que això és una cosa important que cal assegurar-se que vostè ho fa.

1014
01:02:44,650 --> 01:02:47,180
Així que recordi que pot obrir un arxiu, llavors es pot escriure a l'arxiu,

1015
01:02:47,180 --> 01:02:51,270
realitzar operacions a l'arxiu, però després es va a tancar l'arxiu al final.

1016
01:02:51,270 --> 01:02:53,270
>> Qualsevol pregunta sobre l'arxiu de base de E / S? Sí?

1017
01:02:53,270 --> 01:02:58,050
[Pregunta Estudiant, inintel · ligible]

1018
01:02:58,050 --> 01:03:02,480
Aquí mateix. La pregunta és, ¿d'on ve aquest arxiu log.txt aparèixer?

1019
01:03:02,480 --> 01:03:07,890
Bé, si només li donen log.txt, es crea en el mateix directori que l'executable.

1020
01:03:07,890 --> 01:03:10,500
Així que si TEU AQUESTES - >> [pregunta Estudiant, inintel · ligible]

1021
01:03:10,500 --> 01:03:18,830
Sí A la mateixa carpeta, o en el mateix directori, com l'anomeneu.

1022
01:03:18,830 --> 01:03:21,400
Ara la memòria, pila i pila.

1023
01:03:21,400 --> 01:03:23,400
Llavors, com és la memòria s'estableix a l'ordinador?

1024
01:03:23,400 --> 01:03:26,270
Bé, es pot imaginar com una mena de memòria d'aquest bloc aquí.

1025
01:03:26,270 --> 01:03:30,260
I en la memòria que tenim el que s'anomena la pila atrapat allà, i la pila que hi és baix.

1026
01:03:30,260 --> 01:03:34,480
I la pila creix cap avall i la pila creix cap amunt.

1027
01:03:34,480 --> 01:03:38,620
Així com Tommy esmentar - oh, bé, i tenim aquestes altres 4 segments que vaig a arribar a un segon -

1028
01:03:38,620 --> 01:03:42,890
Com Tommy dit abans, vostè sap com es diuen les seves funcions i cridar als altres?

1029
01:03:42,890 --> 01:03:44,930
Ells construeixen aquest tipus de marc de pila.

1030
01:03:44,930 --> 01:03:47,360
Bé, si els principals trucades foo, foo es posen a la pila.

1031
01:03:47,360 --> 01:03:52,430
Foo diu bar, bar arribar a posar a la pila, i que es posen a la pila després.

1032
01:03:52,430 --> 01:03:57,040
I en tornar, cada un d'ells es porten de la pila.

1033
01:03:57,040 --> 01:04:00,140
Què cadascun d'aquests llocs i mantenir la memòria?

1034
01:04:00,140 --> 01:04:03,110
Doncs bé, la part superior, que és el segment de text, conté el programa en si.

1035
01:04:03,110 --> 01:04:06,390
Així que el codi màquina, que hi és, un cop que es compila el programa.

1036
01:04:06,390 --> 01:04:08,520
A continuació, qualsevol inicialitza les variables globals.

1037
01:04:08,520 --> 01:04:12,660
>> Així que hi ha variables globals en el seu programa, i com vostè diu, a = 5,

1038
01:04:12,660 --> 01:04:15,260
que es va posar en aquest segment, i just a sota d'això,

1039
01:04:15,260 --> 01:04:18,990
Té dades globals no inicialitzats, que s'acaba de int a,

1040
01:04:18,990 --> 01:04:20,990
però no et diuen que és igual a res.

1041
01:04:20,990 --> 01:04:23,870
Adonar-se que aquestes són variables globals, pel que estan fora de la principal.

1042
01:04:23,870 --> 01:04:28,560
Així que això significa que les variables globals que es declaren però no s'inicialitza.

1043
01:04:28,560 --> 01:04:32,310
Així que el que està en el munt? La memòria assignada amb malloc, que arribarem a una mica.

1044
01:04:32,310 --> 01:04:35,990
I, finalment, amb la pila té alguna variables locals

1045
01:04:35,990 --> 01:04:39,950
i qualsevol altra funció que es podria anomenar en qualsevol dels seus paràmetres.

1046
01:04:39,950 --> 01:04:43,720
L'última cosa que vostè realment no ha de saber quines són les variables d'entorn fan,

1047
01:04:43,720 --> 01:04:46,700
però cada vegada que s'executi el programa, hi ha alguna cosa associat, igual que

1048
01:04:46,700 --> 01:04:49,550
aquest és el nom de la persona que va executar el programa.

1049
01:04:49,550 --> 01:04:51,550
I això serà una espècie de a la part inferior.

1050
01:04:51,550 --> 01:04:54,540
En termes d'adreces de memòria, que són valors hexadecimals,

1051
01:04:54,540 --> 01:04:58,170
els valors al començament superior a 0, i van tot el camí fins al fons.

1052
01:04:58,170 --> 01:05:00,440
En aquest cas, si vostè està en el sistema de 32-bit,

1053
01:05:00,440 --> 01:05:05,390
la direcció al final serà 0x, seguit per af, perquè això és 32 bits,

1054
01:05:05,390 --> 01:05:10,890
que és de 8 bytes, i en aquest cas 8 bytes correspon a 8 dígits hexadecimals.

1055
01:05:10,890 --> 01:05:20,110
Així que aquí tindrà, com, 0xffffff, i allà tindràs 0.

1056
01:05:20,110 --> 01:05:23,660
Quins són els punters? Alguns de vostès no han cobert això en la secció anterior.

1057
01:05:23,660 --> 01:05:26,660
però sí que vam anar a través d'ella a la conferència, de manera que un punter és només un tipus de dades

1058
01:05:26,660 --> 01:05:34,030
que emmagatzema, en lloc d'algun tipus de valor com 50, que emmagatzema l'adreça d'algun lloc en la memòria.

1059
01:05:34,030 --> 01:05:36,020
Igual que la memòria [inintel · ligible].

1060
01:05:36,020 --> 01:05:41,120
Així que en aquest cas, el que tenim és, tenim un punter a un enter o un int *,

1061
01:05:41,120 --> 01:05:46,210
i conté la següent adreça hexadecimal de 0xLOQUESEA.

1062
01:05:46,210 --> 01:05:50,880
>> Així que el que tenim és, ara, aquest punter en algun lloc de la memòria,

1063
01:05:50,880 --> 01:05:56,020
i això és només una, el valor 50 està en aquesta posició de memòria.

1064
01:05:56,020 --> 01:06:01,810
En alguns sistemes de 32-bit, en tots els sistemes de 32-bits, els punters ocupen 32 bits o 4 bytes.

1065
01:06:01,810 --> 01:06:06,020
Però, per exemple, en un sistema de 64-bit, els punters són de 64 bits.

1066
01:06:06,020 --> 01:06:08,040
Així que això és una cosa que vostè voldrà tenir en compte.

1067
01:06:08,040 --> 01:06:12,310
Així en un sistema d'extrem de bits, un punter és cantoneres de llarg.

1068
01:06:12,310 --> 01:06:17,320
Els punters són una mica difícil de digerir sense coses extres,

1069
01:06:17,320 --> 01:06:20,300
així que anem a anar a través d'un exemple d'assignació de memòria dinàmica.

1070
01:06:20,300 --> 01:06:25,130
Què assignació de memòria dinàmica fa per vostè, o el que anomenem malloc,

1071
01:06:25,130 --> 01:06:29,280
li permet assignar un tipus de dades fora del set.

1072
01:06:29,280 --> 01:06:31,830
Així que aquest tipus de dades és més permanent per a la durada del programa.

1073
01:06:31,830 --> 01:06:36,430
Perquè, com vostè sap, si vostè declara x dins d'una funció, i que recupera el funcionament,

1074
01:06:36,430 --> 01:06:40,910
que ja no tenen accés a les dades emmagatzemades en x.

1075
01:06:40,910 --> 01:06:44,420
Quins indicadors farem és que anem a emmagatzemar els valors de la memòria o la botiga

1076
01:06:44,420 --> 01:06:46,840
en un segment diferent de la memòria, és a dir, el munt.

1077
01:06:46,840 --> 01:06:49,340
Ara, un cop que tornem de la funció, sempre que tenim un punter

1078
01:06:49,340 --> 01:06:54,960
a aquesta ubicació en la memòria, llavors el que podem fer és simplement podem veure els valors allà.

1079
01:06:54,960 --> 01:06:58,020
Vegem un exemple: Aquest és el nostre nou disseny de la memòria.

1080
01:06:58,020 --> 01:07:00,050
I tenim aquesta funció principal.

1081
01:07:00,050 --> 01:07:06,870
El que fa és - està bé, tan simple, dret - int x = 5, que és només una variable a la pila en principal.

1082
01:07:06,870 --> 01:07:12,450
>> D'altra banda, ara es declara un punter que crida als giveMeThreeInts funció.

1083
01:07:12,450 --> 01:07:16,800
I ara entrem en aquesta funció i es crea un nou marc de pila per a això.

1084
01:07:16,800 --> 01:07:20,440
No obstant això, en aquest marc de pila, declarem int * temp,

1085
01:07:20,440 --> 01:07:23,210
que en mallocs 3 punts per a nosaltres.

1086
01:07:23,210 --> 01:07:25,880
Així que la mida de int ens donarà la quantitat de bytes és int,

1087
01:07:25,880 --> 01:07:29,620
malloc i ens dóna que molts bytes d'espai en el munt.

1088
01:07:29,620 --> 01:07:32,890
Així que en aquest cas, hem creat un espai suficient per a 3 nombres enters,

1089
01:07:32,890 --> 01:07:36,830
i el munt està allà dalt, i per això l'he dibuixat més amunt.

1090
01:07:36,830 --> 01:07:42,900
Quan hagis acabat, tornem aquí, només necessita 3 sencers retornats,

1091
01:07:42,900 --> 01:07:47,000
i torna la direcció, en aquest cas més que on la memòria és.

1092
01:07:47,000 --> 01:07:51,250
I ens vam posar punter = interruptor, i allà tenim més que un altre punter.

1093
01:07:51,250 --> 01:07:54,550
Però el que retorna la funció s'apila aquí, i desapareix.

1094
01:07:54,550 --> 01:07:59,250
Així temperatura desapareix, però encara mantenen la direcció d'on

1095
01:07:59,250 --> 01:08:01,850
aquests 3 nombres enters es troben dins de la xarxa.

1096
01:08:01,850 --> 01:08:06,180
Així que en aquest joc, els punters estan en l'àmbit local per al marc d'apilament,

1097
01:08:06,180 --> 01:08:09,860
però la memòria a què es refereixen és al munt.

1098
01:08:09,860 --> 01:08:12,190
>> Això té sentit?

1099
01:08:12,190 --> 01:08:14,960
[Estudiant] Podria repetir això? >> [Joseph] Sí

1100
01:08:14,960 --> 01:08:20,270
Així que si em torno una mica, es veu que la temperatura assignada

1101
01:08:20,270 --> 01:08:23,500
part de la memòria en el munt fins allà.

1102
01:08:23,500 --> 01:08:28,680
Per això, quan aquesta funció, giveMeThreeInts devolucions, aquesta pila d'aquí desapareixerà.

1103
01:08:28,680 --> 01:08:35,819
I amb això cap de les variables, en aquest cas, aquest punter que s'ha assignat en el marc d'apilament.

1104
01:08:35,819 --> 01:08:39,649
Això desapareixerà, però des que vam tornar temp

1105
01:08:39,649 --> 01:08:46,330
i ens vam posar punter = temp, punter ara va a apuntar la mateixa memòria de la ubicació com la temperatura era.

1106
01:08:46,330 --> 01:08:50,370
Així que ara, tot i que perdi temperatura, aquest punter local,

1107
01:08:50,370 --> 01:08:59,109
que encara conserven l'adreça de memòria del que estava assenyalant cap a l'interior d'aquest indicador variable.

1108
01:08:59,109 --> 01:09:03,740
Preguntes? Això pot ser una mica d'un tema confús si vostè no ha passat per sobre de la secció.

1109
01:09:03,740 --> 01:09:09,240
Podem, la seva TF dubte sobre aquest i, per descomptat, podem respondre a les preguntes

1110
01:09:09,240 --> 01:09:11,500
al final de la sessió de revisió per això.

1111
01:09:11,500 --> 01:09:14,220
Però això és una espècie d'un tema complex, i no tinc més exemples que apareixeran

1112
01:09:14,220 --> 01:09:18,790
que ajudarà a aclarir el que en realitat són punters.

1113
01:09:18,790 --> 01:09:22,500
>> En aquest cas, els punters són equivalents a les matrius,

1114
01:09:22,500 --> 01:09:25,229
de manera que només pot utilitzar aquest indicador com la mateixa cosa com una matriu int.

1115
01:09:25,229 --> 01:09:29,840
Així que estic d'indexació en 0, i canviant el primer nombre enter de 1,

1116
01:09:29,840 --> 01:09:39,689
canviant el segon nombre enter de 2, i el sencer tercer a 3.

1117
01:09:39,689 --> 01:09:44,210
Així que més de punters. Bé, recordo Binky.

1118
01:09:44,210 --> 01:09:48,319
En aquest cas hem assignat un punter, o que declarem un punter,

1119
01:09:48,319 --> 01:09:52,760
però al principi, quan m'acaba de declarar un punter, no està apuntant a qualsevol part de la memòria.

1120
01:09:52,760 --> 01:09:54,930
Són només els valors d'escombraries a l'interior de la mateixa.

1121
01:09:54,930 --> 01:09:56,470
Així que no tinc idea d'on aquest indicador està apuntant.

1122
01:09:56,470 --> 01:10:01,630
Té una direcció que s'acaba d'omplir amb 0 i 1, on es va declarar inicialment.

1123
01:10:01,630 --> 01:10:04,810
No puc fer res amb això fins que jo anomeno malloc-hi

1124
01:10:04,810 --> 01:10:08,390
i després em fa una mica d'espai a la pila on puc posar els valors a l'interior.

1125
01:10:08,390 --> 01:10:11,980
D'altra banda, jo no sé el que hi ha dins d'aquesta memòria.

1126
01:10:11,980 --> 01:10:16,780
Així que el primer que has de fer és comprovar si el sistema té prou memòria

1127
01:10:16,780 --> 01:10:20,850
que em torni un nombre enter, en primer lloc, pel que jo estic fent aquesta comprovació.

1128
01:10:20,850 --> 01:10:25,020
Si el punter és nul, el que significa que no té prou espai o algun altre error,

1129
01:10:25,020 --> 01:10:26,320
així que hauria de sortir del meu programa.

1130
01:10:26,320 --> 01:10:29,400
 Però si es va tenir èxit, ara puc utilitzar aquest punter

1131
01:10:29,400 --> 01:10:35,020
i el que fa és * punter es dedueix que la direcció és

1132
01:10:35,020 --> 01:10:38,480
a on aquest valor és, i el posa igual a 1.

1133
01:10:38,480 --> 01:10:41,850
Així que aquí, estem comprovant si aquesta memòria existit.

1134
01:10:41,850 --> 01:10:45,380
>> Quan se sap que existeix, pot posar-hi

1135
01:10:45,380 --> 01:10:50,460
quin és el valor que desitja posar en ell, en aquest cas 1.

1136
01:10:50,460 --> 01:10:53,060
Quan hagi acabat amb ella, la necessitat d'alliberar aquest punter

1137
01:10:53,060 --> 01:10:57,160
perquè hem de tornar al sistema que la memòria que vostè va sol · licitar en primer lloc.

1138
01:10:57,160 --> 01:10:59,690
Com que l'equip no sap quan hàgim acabat amb ell.

1139
01:10:59,690 --> 01:11:02,510
En aquest cas estem dient explícitament, està bé, hem acabat amb aquesta memòria.

1140
01:11:02,510 --> 01:11:10,780
Si algun altre procés que necessita, algun altre programa que necessita, no dubteu a seguir endavant i prendre-ho.

1141
01:11:10,780 --> 01:11:15,110
El que també es pot fer és que només es pot obtenir l'adreça de les variables locals en el set.

1142
01:11:15,110 --> 01:11:19,080
Així int x està dins el marc d'apilament principal.

1143
01:11:19,080 --> 01:11:23,060
I quan utilitzem aquest signe, aquest i l'operador, el que fa és

1144
01:11:23,060 --> 01:11:27,310
Es triga x, i x és només algunes dades en la memòria, però que té una direcció.

1145
01:11:27,310 --> 01:11:33,790
Es troba situat en algun lloc. Llavors, trucant & x, el que això fa és que ens dóna la direcció de x.

1146
01:11:33,790 --> 01:11:38,430
En fer això, estem fent punter al punt on x és a la memòria.

1147
01:11:38,430 --> 01:11:41,710
Ara només ens queda fer alguna cosa com * x, arribarem al 5 de tornada.

1148
01:11:41,710 --> 01:11:43,820
L'estrella es diu eliminació de referències a ell.

1149
01:11:43,820 --> 01:11:46,640
Seguiu la direcció i s'obté el valor de la mateixa s'emmagatzema allà.

1150
01:11:51,000 --> 01:11:53,310
>> Alguna pregunta? Sí?

1151
01:11:53,310 --> 01:11:56,500
[Estudiant] Si no fa la cosa tres puntes, segueix tenint compilar?

1152
01:11:56,500 --> 01:11:59,490
Sí Si no fa la cosa de 3-punts, que encara va a compilar,

1153
01:11:59,490 --> 01:12:02,720
però et vaig a mostrar el que passa en un segon, i sense fer això,

1154
01:12:02,720 --> 01:12:04,860
això és el que anomenem una pèrdua de memòria. No està donant el sistema

1155
01:12:04,860 --> 01:12:07,850
còpies de la seva memòria, així que després d'un temps el programa es va a acumular

1156
01:12:07,850 --> 01:12:10,940
memòria que no està utilitzant, i només pugui usar-lo.

1157
01:12:10,940 --> 01:12:15,750
Si alguna vegada has vist a Firefox amb 1,5 milions de kilobytes a l'ordinador,

1158
01:12:15,750 --> 01:12:17,840
en l'administrador de tasques, això és el que està passant.

1159
01:12:17,840 --> 01:12:20,760
Vostè té una pèrdua de memòria en el programa que no està manejant.

1160
01:12:23,080 --> 01:12:26,240
Llavors, com fa la feina punter aritmètica?

1161
01:12:26,240 --> 01:12:29,480
Bé, l'aritmètica de punters és una espècie d'indexació com en una matriu.

1162
01:12:29,480 --> 01:12:36,370
En aquest cas, tinc un punter, i el que jo faig és fer punt punter al primer element

1163
01:12:36,370 --> 01:12:42,100
d'aquesta sèrie de tres nombres enters que he assignat.

1164
01:12:42,100 --> 01:12:46,670
I ara què faig, punter estrella només canvia el primer element de la llista.

1165
01:12:46,670 --> 01:12:49,140
Estrella punter +1 punts aquí.

1166
01:12:49,140 --> 01:12:53,140
Així punter està per aquí, un punter és per aquí, punter +2 és per aquí.

1167
01:12:53,140 --> 01:12:56,610
>> Així només afegir 1 és el mateix que moure al llarg d'aquesta matriu.

1168
01:12:56,610 --> 01:12:59,880
El que fem és, quan fem un punter a obtenir l'adreça per aquí,

1169
01:12:59,880 --> 01:13:04,180
i amb la finalitat d'obtenir el valor d'aquí, es posa un estel en tota l'expressió de

1170
01:13:04,180 --> 01:13:05,990
per eliminació de referències.

1171
01:13:05,990 --> 01:13:09,940
Així, en aquest cas, m'estic donant el primer lloc en aquesta matriu a 1,

1172
01:13:09,940 --> 01:13:13,970
ubicació a 2 segons, i tercera ubicació a 3.

1173
01:13:13,970 --> 01:13:18,180
Llavors, què estic fent aquí és que estic imprimint nostre punter +1,

1174
01:13:18,180 --> 01:13:19,970
que només em dóna 2.

1175
01:13:19,970 --> 01:13:23,650
Ara estic incrementant punter, per la qual cosa és igual punter punter +1,

1176
01:13:23,650 --> 01:13:26,780
que es mou cap endavant.

1177
01:13:26,780 --> 01:13:30,810
I ara si em imprimeixi un punter, punter +1 és ara 3 anys,

1178
01:13:30,810 --> 01:13:33,990
que en aquest cas s'imprimeix 3.

1179
01:13:33,990 --> 01:13:36,560
I per alguna cosa gratis, el punter que li dono

1180
01:13:36,560 --> 01:13:40,540
ha d'apuntar al principi de la matriu que vaig tornar de malloc.

1181
01:13:40,540 --> 01:13:43,430
Així que, en aquest cas, si jo hagués de cridar 3 aquí, això no seria correcte,

1182
01:13:43,430 --> 01:13:45,070
perquè és al centre de la matriu.

1183
01:13:45,070 --> 01:13:48,820
He de resta per arribar a la ubicació original

1184
01:13:48,820 --> 01:13:50,420
l'acte inicial abans que pugui alliberar-lo.

1185
01:13:56,300 --> 01:13:58,450
Per tant, aquí hi ha un exemple més complicat.

1186
01:13:58,450 --> 01:14:03,360
En aquest cas, estem assignant 7 caràcters en una matriu de caràcters.

1187
01:14:03,360 --> 01:14:06,480
>> I en aquest cas el que estem fent és que estem recórrer els 6 primers d'ells,

1188
01:14:06,480 --> 01:14:09,900
i els estem establint a la Z.

1189
01:14:09,900 --> 01:14:13,350
Així, per int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Per tant, el punter + i només ens donarà, en aquest cas,

1191
01:14:16,220 --> 01:14:20,860
punter, punter +1, 2 punter, punter 3, i així successivament i així successivament en el bucle.

1192
01:14:20,860 --> 01:14:24,040
Què farà és que arribi aquesta direcció, desreferencia per obtenir el valor,

1193
01:14:24,040 --> 01:14:27,440
i que els canvis a un valor Z.

1194
01:14:27,440 --> 01:14:30,350
Després, al final recorda que això és una cadena, no?

1195
01:14:30,350 --> 01:14:33,560
Totes les cadenes han d'acabar amb el caràcter nul de terminació.

1196
01:14:33,560 --> 01:14:38,620
Per tant, el que faig és a punter 6 vaig posar el caràcter terminador nul polz

1197
01:14:38,620 --> 01:14:43,980
I ara el que estic fent bàsicament aquí està implementant printf per a una cadena, no?

1198
01:14:43,980 --> 01:14:46,190
>> Així que, quan printf ara quan s'ha arribat al final d'una cadena?

1199
01:14:46,190 --> 01:14:48,230
Quan arribi el caràcter nul de terminació.

1200
01:14:48,230 --> 01:14:52,030
Així, en aquest cas, els meus punts punter original al principi d'aquesta matriu.

1201
01:14:52,030 --> 01:14:56,410
Puc imprimir el caràcter primer en sortir. El moc a través d'un.

1202
01:14:56,410 --> 01:14:58,420
Puc publicar aquell personatge. El moc de nou.

1203
01:14:58,420 --> 01:15:02,180
I segueixo fent això fins que arribi al final.

1204
01:15:02,180 --> 01:15:07,750
I ara el punter * Final voluntat dereference això i el caràcter nul de terminació de tornada.

1205
01:15:07,750 --> 01:15:11,780
I així la meva bucle while s'executa només quan aquest valor no és el caràcter nul de terminació.

1206
01:15:11,780 --> 01:15:13,770
Així que, ara surto d'aquest bucle.

1207
01:15:18,780 --> 01:15:21,180
I pel que si li resta 6 d'aquest indicador,

1208
01:15:21,180 --> 01:15:22,860
Torno fins al final fins al principi.

1209
01:15:22,860 --> 01:15:27,880
Recorda, jo estic fent això perquè he d'anar al principi per tal de alliberar-la.

1210
01:15:27,880 --> 01:15:30,270
>> Per tant, sé que era molt. Hi ha alguna pregunta?

1211
01:15:30,270 --> 01:15:31,870
Si us plau, sí?

1212
01:15:31,870 --> 01:15:36,610
[Inintel · ligible pregunta Estudiant]

1213
01:15:36,610 --> 01:15:38,190
Es pot dir que més fort? Em sap greu.

1214
01:15:38,190 --> 01:15:44,140
[Estudiant] En l'última diapositiva just abans que va alliberar al punter,

1215
01:15:44,140 --> 01:15:47,300
on estaves realment canviar el valor del punter?

1216
01:15:47,300 --> 01:15:50,370
[Josep] Per tant, aquí mateix. >> [Estudiant] Oh, està bé.

1217
01:15:50,370 --> 01:15:51,890
[Josep] Per tant, tinc un punter menys negatiu, dreta,

1218
01:15:51,890 --> 01:15:54,140
que mou la cosa de nou, i després ho alliberi,

1219
01:15:54,140 --> 01:15:57,000
perquè aquest punter ha de ser assenyalat al principi de la matriu.

1220
01:15:57,000 --> 01:16:00,420
[Estudiant] Però això no caldria que es va aturar després d'aquesta línia.

1221
01:16:00,420 --> 01:16:03,130
[José] Així que, si m'hagués detingut després d'això, això seria considerat una pèrdua de memòria,

1222
01:16:03,130 --> 01:16:04,810
perquè no s'ha executat el programa gratuït.

1223
01:16:04,810 --> 01:16:11,290
[Estudiant] I [inintel · ligible] després de les tres primeres línies on tenies punter +1 [inintel · ligible].

1224
01:16:11,290 --> 01:16:13,140
[José] Uh-huh. Llavors, ¿quina és la pregunta que cal?

1225
01:16:13,140 --> 01:16:14,780
Em sap greu. No, no. Vaja, vaja, si us plau.

1226
01:16:14,780 --> 01:16:16,870
[Estudiant] Per tant, no estem canviant el valor de punters.

1227
01:16:16,870 --> 01:16:19,130
No hauria hagut de fer punter menys negatiu.

1228
01:16:19,130 --> 01:16:19,730
[José] Sí, exactament.

1229
01:16:19,730 --> 01:16:21,890
Per tant, quan faig un punter i el punter +2,

1230
01:16:21,890 --> 01:16:24,410
No faré punter és igual a un punter.

1231
01:16:24,410 --> 01:16:27,260
Per tant, el punter només es queda apuntant al principi de la matriu.

1232
01:16:27,260 --> 01:16:31,460
És només quan ho faig plus plus que estableix el valor de nou en el punter,

1233
01:16:31,460 --> 01:16:33,550
que en realitat es mou al llarg d'aquest.

1234
01:16:36,860 --> 01:16:37,780
Està bé.

1235
01:16:40,550 --> 01:16:42,030
Més preguntes?

1236
01:16:44,680 --> 01:16:47,790
>> Un cop més, si això és una espècie de insuportable, això es tractarà en la sessió.

1237
01:16:47,790 --> 01:16:50,710
Pregúntele al seu company d'ensenyament en això, i podem respondre a les preguntes al final.

1238
01:16:53,510 --> 01:16:56,600
I en general no ens agrada que facis això menys.

1239
01:16:56,600 --> 01:16:59,760
Això ha de m'exigeixen fer el seguiment de tot el que he posició de la matriu.

1240
01:16:59,760 --> 01:17:04,520
Així que, en general, això és només per explicar com funciona l'aritmètica de punters.

1241
01:17:04,520 --> 01:17:07,970
Però el que normalment volem fer és que ens agrada per crear una còpia del punter,

1242
01:17:07,970 --> 01:17:11,640
i després utilitzarem aquesta còpia quan ens movem al voltant de la cadena.

1243
01:17:11,640 --> 01:17:14,660
Per tant, en aquests casos s'utilitza la còpia per imprimir tota la cadena,

1244
01:17:14,660 --> 01:17:19,040
però no hem de fer com punter menys 6 o portar un registre de quant ens traslladem en això,

1245
01:17:19,040 --> 01:17:22,700
només perquè sabem que el nostre punt original segueix assenyalar el començament de la llista

1246
01:17:22,700 --> 01:17:25,340
i tot el que va ser alterat aquesta còpia.

1247
01:17:25,340 --> 01:17:28,250
Així, en general, modificar les còpies del seu punter original.

1248
01:17:28,250 --> 01:17:32,350
No tracti d'una cosa així com - no alterar les còpies originals.

1249
01:17:32,350 --> 01:17:35,290
Tractar d'alterar úniques còpies del seu original.

1250
01:17:41,540 --> 01:17:44,870
Així, es dóna compte quan passem la cadena a printf

1251
01:17:44,870 --> 01:17:48,990
vostè no ha de posar una estrella al front d'ella com ho vam fer amb tots els desreferencia altres, no?

1252
01:17:48,990 --> 01:17:54,180
Per tant, si imprimeix la cadena s% espera que tot és una adreça,

1253
01:17:54,180 --> 01:17:57,610
i en aquest cas un punter o en aquest cas com una matriu de caràcters.

1254
01:17:57,610 --> 01:18:00,330
>> Personatges, char * s, i les matrius són la mateixa cosa.

1255
01:18:00,330 --> 01:18:03,690
Pointer és caràcters i matrius de caràcters són la mateixa cosa.

1256
01:18:03,690 --> 01:18:05,720
I així, tot el que hem de fer és passar punter.

1257
01:18:05,720 --> 01:18:08,150
No hem de passar com punter * ni res d'això.

1258
01:18:13,110 --> 01:18:14,930
Per tant, les matrius i els punters són la mateixa cosa.

1259
01:18:14,930 --> 01:18:19,160
Quan estàs fent alguna cosa com x [i] per aquí per una matriu,

1260
01:18:19,160 --> 01:18:21,960
el que està fent sota el capó és el que està dient, està bé, es tracta d'una matriu de caràcters,

1261
01:18:21,960 --> 01:18:23,690
pel que és un punter.

1262
01:18:23,690 --> 01:18:26,510
I així, x són la mateixa cosa,

1263
01:18:26,510 --> 01:18:28,650
i per tant el que fa és que afegeix Yax,

1264
01:18:28,650 --> 01:18:31,820
el que és el mateix que moure cap endavant en la memòria que molt.

1265
01:18:31,820 --> 01:18:34,930
I ara x + i ens dóna algun tipus de direcció,

1266
01:18:34,930 --> 01:18:37,570
i eliminar la referència al domicili o segueixi la fletxa

1267
01:18:37,570 --> 01:18:41,640
on aquesta ubicació en la memòria és i obtenim el valor de la ubicació en la memòria.

1268
01:18:41,640 --> 01:18:43,720
Així, de manera que aquests dos són exactament la mateixa cosa.

1269
01:18:43,720 --> 01:18:45,840
És només una manera d'expressar.

1270
01:18:45,840 --> 01:18:48,090
Ells fan el mateix. Són només sintàctica diferents entre si.

1271
01:18:51,500 --> 01:18:57,590
>> Així que, què pot anar malament amb punters? Igual, molt. Bé. Així, les coses dolentes.

1272
01:18:57,590 --> 01:19:02,410
Algunes de les coses dolentes que pot fer no està comprovant si la seva crida malloc retorna un valor nul, no?

1273
01:19:02,410 --> 01:19:06,560
En aquest cas, estic demanant al sistema que em donés - Quin és aquest nombre?

1274
01:19:06,560 --> 01:19:11,200
Com 2 mil milions de vegades 4, pel fet que la mida d'un enter de 4 bytes.

1275
01:19:11,200 --> 01:19:13,810
Ho estic demanant com 8 milions de bytes.

1276
01:19:13,810 --> 01:19:17,270
Per descomptat, el meu equip no serà capaç de donar-me volta que molta memòria.

1277
01:19:17,270 --> 01:19:20,960
I no comprovar si aquest és nul, de manera que quan tractem d'eliminar la referència que hi -

1278
01:19:20,960 --> 01:19:24,270
segueixi la fletxa a on es va a - no tenim aquesta memòria.

1279
01:19:24,270 --> 01:19:27,150
Això és el que anomenem l'eliminació de referències a un punter nul.

1280
01:19:27,150 --> 01:19:29,710
I això fa que essencialment violació de segment.

1281
01:19:29,710 --> 01:19:31,790
Aquesta és una de les formes en què pots violació de segment.

1282
01:19:34,090 --> 01:19:38,090
Altres coses dolentes que vostè pot fer - bo.

1283
01:19:38,090 --> 01:19:40,650
Això va ser desreferencia un punter nul. Bé.

1284
01:19:40,650 --> 01:19:45,160
Altres coses dolentes - bé, en fixar que vostè acaba de posar un xec en allà

1285
01:19:45,160 --> 01:19:46,980
que comprova si el punter és nul

1286
01:19:46,980 --> 01:19:51,000
i sortir del programa si passa que malloc retorna un punter nul.

1287
01:19:55,110 --> 01:19:59,850
Aquest és el còmic xkcd. La gent ho entenc ara. Gairebé.

1288
01:20:06,120 --> 01:20:09,350
>> Així, la memòria. I em vaig anar per això.

1289
01:20:09,350 --> 01:20:12,000
Estem trucant a malloc en un bucle, però cada vegada que fem una crida a malloc

1290
01:20:12,000 --> 01:20:14,370
estem perdent la pista d'on aquest indicador fa referència,

1291
01:20:14,370 --> 01:20:15,750
perquè ho estem colpejant fortament.

1292
01:20:15,750 --> 01:20:18,410
Per tant, la primera crida a malloc em fa memòria aquí.

1293
01:20:18,410 --> 01:20:19,990
Els meus punters punters a això.

1294
01:20:19,990 --> 01:20:23,020
Ara, jo no ho alliberarà, així que ara jo dic malloc nou.

1295
01:20:23,020 --> 01:20:26,070
Ara apunta cap aquí. Ara la meva memòria apunta fins aquí.

1296
01:20:26,070 --> 01:20:27,640
Apuntant cap aquí. Apuntant cap aquí.

1297
01:20:27,640 --> 01:20:31,820
Però he perdut el compte de les adreces de tota la memòria per aquí que em van assignar.

1298
01:20:31,820 --> 01:20:35,100
I ara no tinc cap referència a ells mai més.

1299
01:20:35,100 --> 01:20:37,230
Per tant, no puc alliberar fora d'aquest bucle.

1300
01:20:37,230 --> 01:20:39,390
I així, amb la finalitat de fixar alguna cosa com això,

1301
01:20:39,390 --> 01:20:42,250
si s'oblida de la memòria lliure i s'obté aquesta pèrdua de memòria,

1302
01:20:42,250 --> 01:20:45,810
Cal alliberar la memòria dins aquest bucle quan hagueu acabat amb ell.

1303
01:20:45,810 --> 01:20:51,400
Bé, això és el que passa. Sé que molts de vostès odien això.

1304
01:20:51,400 --> 01:20:55,270
Però ara - yay! S'obté com 44.000 kilobytes.

1305
01:20:55,270 --> 01:20:57,110
Així, que es lliure en l'extrem del bucle,

1306
01:20:57,110 --> 01:20:59,770
i això va a alliberar només la memòria cada vegada.

1307
01:20:59,770 --> 01:21:03,620
En essència, el programa no té una pèrdua de memòria més.

1308
01:21:03,620 --> 01:21:08,150
>> I ara una altra cosa que pots fer és alliberar la memòria que vostè ha demanat dues vegades.

1309
01:21:08,150 --> 01:21:11,060
En aquest cas, és una cosa malloc, canvia el seu valor.

1310
01:21:11,060 --> 01:21:13,140
Vostè es lliure un cop perquè vas dir que havies acabat amb ella.

1311
01:21:13,140 --> 01:21:14,940
Però després el va alliberar de nou.

1312
01:21:14,940 --> 01:21:16,730
Això és una cosa que és bastant dolent.

1313
01:21:16,730 --> 01:21:18,820
No va a violació de segment al principi,

1314
01:21:18,820 --> 01:21:23,350
però després d'una estona el que això fa és alliberar aquesta doble corromp l'estructura de munt,

1315
01:21:23,350 --> 01:21:27,200
i vostè aprendrà una mica més en això vostè decideix prendre una classe com CS61.

1316
01:21:27,200 --> 01:21:30,000
Però essencialment després d'un temps l'equip va a confondre

1317
01:21:30,000 --> 01:21:33,010
sobre el que les posicions de memòria on estan i cap a on s'emmagatzema -

1318
01:21:33,010 --> 01:21:34,800
on les dades s'emmagatzemen a la memòria.

1319
01:21:34,800 --> 01:21:38,080
I així alliberar un punter dues vegades és negatiu que no vull fer.

1320
01:21:38,080 --> 01:21:41,600
>> Altres coses que poden sortir malament no useu sizeof.

1321
01:21:41,600 --> 01:21:44,460
Així que, en aquest cas malloc 8 bytes,

1322
01:21:44,460 --> 01:21:46,700
i això és el mateix que dos enters, no?

1323
01:21:46,700 --> 01:21:49,580
Llavors, això és perfectament segur, però ho és?

1324
01:21:49,580 --> 01:21:52,160
Bé, com Lucas va parlar sobre diferents arquitectures,

1325
01:21:52,160 --> 01:21:54,220
sencers són de longituds diferents.

1326
01:21:54,220 --> 01:21:57,970
Per tant, l'aparell que està utilitzant, els enters són al voltant de 4 bytes,

1327
01:21:57,970 --> 01:22:02,370
però en algun altre sistema que podria ser de 8 bytes o poden ser 16 bytes.

1328
01:22:02,370 --> 01:22:05,680
Per tant, si només utilitzen aquest número per aquí,

1329
01:22:05,680 --> 01:22:07,310
aquest programa pot treballar en l'aparell,

1330
01:22:07,310 --> 01:22:10,360
però no va a assignar suficient memòria en algun altre sistema.

1331
01:22:10,360 --> 01:22:14,020
En aquest cas, això és el que l'operador sizeof s'utilitza per.

1332
01:22:14,020 --> 01:22:16,880
Quan cridem a sizeof (int), el que fa és

1333
01:22:16,880 --> 01:22:21,910
 que ens dóna la mida d'un sencer en la matriu que s'executa el programa.

1334
01:22:21,910 --> 01:22:25,490
Així, en aquest cas, sizeof (int) tornarà 4 en alguna cosa com l'aparell,

1335
01:22:25,490 --> 01:22:29,980
i ara aquesta voluntat 4 * 2, que és 8,

1336
01:22:29,980 --> 01:22:32,330
que és només la quantitat d'espai necessari per dos enters.

1337
01:22:32,330 --> 01:22:36,710
En un sistema diferent, si és un int com 16 bytes o 8 bytes

1338
01:22:36,710 --> 01:22:39,380
que només tornarà suficients bytes per emmagatzemar aquesta quantitat.

1339
01:22:41,830 --> 01:22:45,310
>> I, finalment, les estructures.

1340
01:22:45,310 --> 01:22:48,340
Per tant, si es vol guardar una taula de sudoku en la memòria, com podem fer això?

1341
01:22:48,340 --> 01:22:51,570
Es podria pensar en com una variable per a la primera cosa,

1342
01:22:51,570 --> 01:22:53,820
una variable per a la segona cosa, una variable per a la tercera cosa,

1343
01:22:53,820 --> 01:22:56,420
una variable per a la quarta cosa - dolent, oi?

1344
01:22:56,420 --> 01:23:00,750
Per tant, una millora que vostè pot fer sobre això és fer una matriu de 9 x 9.

1345
01:23:00,750 --> 01:23:04,480
Això està bé, però el que si desitja associar altres coses amb la targeta de sudoku

1346
01:23:04,480 --> 01:23:06,490
com el que la dificultat de la junta és,

1347
01:23:06,490 --> 01:23:11,740
o, per exemple, quin és la seva puntuació és, o quant temps ha pres vostè per resoldre aquest fòrum?

1348
01:23:11,740 --> 01:23:14,970
Bé, el que puc fer és que vostè pot crear una estructura.

1349
01:23:14,970 --> 01:23:18,910
El que estic dient és, bàsicament, estic definint aquesta estructura per aquí,

1350
01:23:18,910 --> 01:23:23,230
i estic definint un tauler de sudoku que consisteix en una placa que és 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> I el que ha de té punters a el nom del nivell.

1352
01:23:26,650 --> 01:23:30,730
També compta amb x i i, que són les coordenades d'on estic ara mateix.

1353
01:23:30,730 --> 01:23:35,980
També ha temps passat [inintel · ligible], i té el nombre total de moviments que he oferta fins ara.

1354
01:23:35,980 --> 01:23:40,010
I així, en aquest cas, pot agrupar una gran quantitat de dades en una sola estructura

1355
01:23:40,010 --> 01:23:42,790
en lloc de tenir-lo com volar al voltant de la mateixa diferents variables

1356
01:23:42,790 --> 01:23:44,540
que en realitat no puc seguir la pista.

1357
01:23:44,540 --> 01:23:49,720
I això ens permet tenir només sintaxi agradable per fer referència a una espècie de coses diferents dins d'aquesta estructura.

1358
01:23:49,720 --> 01:23:53,430
Jo només puc fer board.board, i em surt el tauler sudoku esquena.

1359
01:23:53,430 --> 01:23:56,320
Board.level, em surt com és de difícil.

1360
01:23:56,320 --> 01:24:00,540
Board.x board.y i em donen les coordenades d'on podria estar en el tauler.

1361
01:24:00,540 --> 01:24:04,730
I, llavors, accedir al que anomenem camps de l'estructura.

1362
01:24:04,730 --> 01:24:08,840
Això defineix sudokuBoard, que és un tipus que tinc.

1363
01:24:08,840 --> 01:24:14,800
I ara som aquí. Tinc una variable anomenada "junta" de sudokuBoard tipus.

1364
01:24:14,800 --> 01:24:18,820
I així que ara puc accedir a tots els camps que componen aquesta estructura aquí.

1365
01:24:20,830 --> 01:24:22,450
>> Qualsevol pregunta sobre les estructures? Sí?

1366
01:24:22,450 --> 01:24:25,890
[Estudiant] Per int x, i, al mateix temps que va declarar en una línia? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Estudiant] Així que, pots fer això amb tots ells?

1368
01:24:27,400 --> 01:24:31,200
Igual que en x, I coma vegades que el total?

1369
01:24:31,200 --> 01:24:34,460
[José] Sí, definitivament es pot fer això, però la raó per la qual posar x i i en la mateixa línia -

1370
01:24:34,460 --> 01:24:36,330
i la pregunta és per què només podem fer-ho a la mateixa línia?

1371
01:24:36,330 --> 01:24:38,600
Per què no només cal posar tot això en la mateixa línia és

1372
01:24:38,600 --> 01:24:42,090
x i i es relacionen entre si,

1373
01:24:42,090 --> 01:24:44,780
i això és només estilísticament més correcte, en cert sentit,

1374
01:24:44,780 --> 01:24:46,600
perquè és agrupar dues coses en la mateixa línia

1375
01:24:46,600 --> 01:24:49,340
aquest tipus de com es refereixen a la mateixa cosa.

1376
01:24:49,340 --> 01:24:51,440
I m'acaba de trencar aquests trossos. És només una cosa estil.

1377
01:24:51,440 --> 01:24:53,720
És funcionalment no fa cap diferència en absolut.

1378
01:24:58,150 --> 01:24:59,270
Qualsevol altra pregunta sobre les estructures?

1379
01:25:03,030 --> 01:25:06,620
Es pot definir una Pokédex amb una estructura.

1380
01:25:06,620 --> 01:25:11,720
Un Pokémon té un nombre i té una carta, un propietari, un tipus.

1381
01:25:11,720 --> 01:25:16,990
I llavors, si vostè té una gran varietat de Pokémon, vostè pot fer una Pokédex, oi?

1382
01:25:16,990 --> 01:25:20,810
D'acord, genial. Per tant, les preguntes sobre les estructures. Els que estan relacionats amb les estructures.

1383
01:25:20,810 --> 01:25:25,270
>> Finalment, el BGF. Què GDB permeten fer? Permet depurar el programa.

1384
01:25:25,270 --> 01:25:27,650
I si vostè no ha utilitzat GDB, em va recomanar veure el curt

1385
01:25:27,650 --> 01:25:31,250
i repassant el que GDB és a dir, com es treballa amb ell, com pot usar-lo,

1386
01:25:31,250 --> 01:25:32,900
i provar-ho en un programa.

1387
01:25:32,900 --> 01:25:37,400
I així ho GDB li permet fer és que li permet pausar la [inintel · ligible] seu programa

1388
01:25:37,400 --> 01:25:38,920
i una línia de pràctica.

1389
01:25:38,920 --> 01:25:42,600
Per exemple, vull fer una pausa en l'execució com la línia 3 del meu programa,

1390
01:25:42,600 --> 01:25:46,010
i ja que estic a la línia 3 que pot imprimir tots els valors que hi són.

1391
01:25:46,010 --> 01:25:49,710
I així el que anomenem com una pausa en una línia

1392
01:25:49,710 --> 01:25:52,350
Se li diem posar un punt d'interrupció en aquesta línia

1393
01:25:52,350 --> 01:25:55,920
i llavors podrem imprimir les variables en l'estat del programa en aquest moment.

1394
01:25:55,920 --> 01:25:58,990
>> Podem llavors des d'allà pas a pas el programa línia per línia.

1395
01:25:58,990 --> 01:26:03,200
I llavors pot mirar l'estat de la pila en el moment.

1396
01:26:03,200 --> 01:26:08,600
I així, per tal d'utilitzar GDB, el que fem és que anomenem so metàl · lic a l'arxiu C,

1397
01:26:08,600 --> 01:26:11,290
però hem de passar la bandera ggdb.

1398
01:26:11,290 --> 01:26:15,850
I un cop que hagis acabat amb això en tenim prou amb executar gdb a l'arxiu de sortida resultant.

1399
01:26:15,850 --> 01:26:18,810
I perquè pugui obtenir una mica de massa com de text com aquest,

1400
01:26:18,810 --> 01:26:21,990
però en realitat l'única cosa que has de fer és introduir comandaments al principi.

1401
01:26:21,990 --> 01:26:24,250
Trencar principal posa un punt de ruptura en principal.

1402
01:26:24,250 --> 01:26:28,470
Llista 400 enumera les línies de codi al voltant de la línia 400.

1403
01:26:28,470 --> 01:26:31,410
I així, en aquest cas, només pot mirar al voltant i dir, oh,

1404
01:26:31,410 --> 01:26:34,360
Vull establir un punt d'interrupció en la línia 397, que és aquesta línia,

1405
01:26:34,360 --> 01:26:37,170
i després el programa s'executa en aquest pas i que trencarà.

1406
01:26:37,170 --> 01:26:41,120
Es farà una pausa allà, i vostè pot imprimir, per exemple, el valor de baixa o alta.

1407
01:26:41,120 --> 01:26:46,410
I així hi ha un munt d'opcions que necessita saber,

1408
01:26:46,410 --> 01:26:48,660
i aquesta presentació pujarà al lloc web,

1409
01:26:48,660 --> 01:26:54,000
així que si el que desitja fer referència a aquests o similars les va posar en els teus fulls de trucs, no dubti.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Això va ser Quiz Revisió 0, i anem a quedar si té alguna pregunta.

1411
01:27:00,650 --> 01:27:03,850
Està bé.

1412
01:27:03,850 --> 01:27:09,030
>>  [Aplaudiment]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]