1
00:00:00,000 --> 00:00:03,381
>> [REPRODUCCIÓN DE MÚSICA]

2
00:00:03,381 --> 00:00:10,626

3
00:00:10,626 --> 00:00:11,610
>> [REPRODUCCIÓN DE VÍDEO]

4
00:00:11,610 --> 00:00:13,640
>> -Él está mintiendo.

5
00:00:13,640 --> 00:00:14,380
>> -¿Acerca de?

6
00:00:14,380 --> 00:00:17,182
>> -No lo sé.

7
00:00:17,182 --> 00:00:19,990
>> -¿Entonces que sabemos?

8
00:00:19,990 --> 00:00:23,145
>> -Que A las 9:15, Ray
Santoya estaba en el cajero automático.

9
00:00:23,145 --> 00:00:23,644
-Sí.

10
00:00:23,644 --> 00:00:27,030
Así que la pregunta es, ¿qué
estaba haciendo a las 9:16?

11
00:00:27,030 --> 00:00:29,720
>> -Shooting Milímetro 9 en algo.

12
00:00:29,720 --> 00:00:31,540
Tal vez vio al francotirador.

13
00:00:31,540 --> 00:00:33,412
>> -O Fue trabajar con él.

14
00:00:33,412 --> 00:00:34,340
>> -Espera.

15
00:00:34,340 --> 00:00:36,200
Vuelve una.

16
00:00:36,200 --> 00:00:36,975
>> -¿Que ves?

17
00:00:36,975 --> 00:00:44,400

18
00:00:44,400 --> 00:00:47,805
>> -Lleve Su rostro hasta pantalla completa.

19
00:00:47,805 --> 00:00:48,680
>> -Sus Gafas.

20
00:00:48,680 --> 00:00:50,060
>> -Hay Una reflexión.

21
00:00:50,060 --> 00:01:00,455

22
00:01:00,455 --> 00:01:02,280
>> -Es El equipo de béisbol de Nuevitas.

23
00:01:02,280 --> 00:01:03,110
Esa es su logotipo.

24
00:01:03,110 --> 00:01:05,820
>> -Y Él está hablando con
el que lleva la chaqueta.

25
00:01:05,820 --> 00:01:06,670
>> [FIN DE REPRODUCCIÓN]

26
00:01:06,670 --> 00:01:07,628
>> DAVID MALAN: De acuerdo.

27
00:01:07,628 --> 00:01:11,210
Esto es CS50 y esto es un poco más
de [inaudible] con la que estás

28
00:01:11,210 --> 00:01:12,890
escarceos con el problema de establecer cuatro.

29
00:01:12,890 --> 00:01:16,606
Hoy empezamos a mirar un poco más
profundamente en estas cosas llamadas punteros,

30
00:01:16,606 --> 00:01:18,480
que aunque es
un tema bastante arcano,

31
00:01:18,480 --> 00:01:20,813
resulta que se va
ser el medio por el cual nos

32
00:01:20,813 --> 00:01:24,320
puede empezar a construir y montaje
programas mucho más sofisticados.

33
00:01:24,320 --> 00:01:28,150
Pero lo hicimos en el pasado miércoles
por medio de algunos claymation primero.

34
00:01:28,150 --> 00:01:30,190
Así que esto, recordar, es
Binky y nosotros lo utilizamos

35
00:01:30,190 --> 00:01:33,148
a echar un vistazo a un programa que
realmente no hacer nada interesante,

36
00:01:33,148 --> 00:01:34,950
pero sí reveló algunos problemas.

37
00:01:34,950 --> 00:01:38,570
Así que para empezar hoy, ¿por qué no nos andamos
rápidamente a través de algunos de estos pasos,

38
00:01:38,570 --> 00:01:41,920
tratar de destilar en términos de humanos
exactamente lo que está pasando aquí

39
00:01:41,920 --> 00:01:45,410
y por qué esto es malo, y luego seguir adelante
y realmente empezar a construir algo

40
00:01:45,410 --> 00:01:46,309
con esta técnica?

41
00:01:46,309 --> 00:01:48,350
Así que estos fueron los primeros
dos líneas en este programa

42
00:01:48,350 --> 00:01:51,340
y en términos simples, lo que
están haciendo estas dos líneas?

43
00:01:51,340 --> 00:01:55,600
Alguien que es razonablemente cómodo
con lo que ha declarado en la pantalla?

44
00:01:55,600 --> 00:01:58,340

45
00:01:58,340 --> 00:02:00,120
¿Cuáles son estas dos líneas que hacen?

46
00:02:00,120 --> 00:02:02,070
No es todo lo que
diferente de semana uno,

47
00:02:02,070 --> 00:02:03,611
pero que una novedad símbolo especial.

48
00:02:03,611 --> 00:02:04,152
¿Sí?

49
00:02:04,152 --> 00:02:05,628
Volver allí.

50
00:02:05,628 --> 00:02:07,092
>> AUDIENCIA: Declarar punteros?

51
00:02:07,092 --> 00:02:08,050
DAVID MALAN: Diga otra vez?

52
00:02:08,050 --> 00:02:08,860
AUDIENCIA: Declarar punteros?

53
00:02:08,860 --> 00:02:11,776
DAVID MALAN: punteros declarar y
vamos a refinar un poco más.

54
00:02:11,776 --> 00:02:14,050
AUDIENCIA: [inaudible]
dirección x y y.

55
00:02:14,050 --> 00:02:15,300
DAVID MALAN: Y luego abordar.

56
00:02:15,300 --> 00:02:18,550
Así que específicamente lo que estamos haciendo
Somos nosotros declaramos dos variables.

57
00:02:18,550 --> 00:02:21,252
Estas variables, sin embargo, van
ser de tipo int estrella, que

58
00:02:21,252 --> 00:02:23,210
significa más específicamente
van a almacenar

59
00:02:23,210 --> 00:02:26,450
la dirección de un int,
respectivamente, x e y.

60
00:02:26,450 --> 00:02:27,660
Ahora hay ningún valor?

61
00:02:27,660 --> 00:02:32,621
¿Hay direcciones reales en estos
dos variables en este punto en el tiempo?

62
00:02:32,621 --> 00:02:33,120
No.

63
00:02:33,120 --> 00:02:35,030
Simplemente ha llamados valores de basura.

64
00:02:35,030 --> 00:02:38,120
Si en realidad no asigna un
variables, lo que fuera en la memoria RAM

65
00:02:38,120 --> 00:02:42,224
previamente se va a llenar de ceros
y los dos de esas variables.

66
00:02:42,224 --> 00:02:44,140
Pero aún no sabemos
lo que son y eso es

67
00:02:44,140 --> 00:02:47,060
va a ser la clave de por qué Binky
perdido la cabeza la semana pasada.

68
00:02:47,060 --> 00:02:49,980
>> Así que este era el claymation
encarnación de esta

69
00:02:49,980 --> 00:02:53,580
por el que usted tiene sólo dos variables
pequeñas piezas circulares de arcilla,

70
00:02:53,580 --> 00:02:57,330
que puede almacenar variables, pero como
las flechas envueltas sugieren,

71
00:02:57,330 --> 00:03:00,640
no están realmente apuntando
a cualquier lugar conocido per se.

72
00:03:00,640 --> 00:03:03,670
Así que tuvimos esta línea, y esto
era nuevo la semana pasada, malloc para la memoria

73
00:03:03,670 --> 00:03:07,130
asignación, que es sólo una forma elegante
de decirle al sistema operativo, Linux

74
00:03:07,130 --> 00:03:09,750
o Mac OS o Windows,
oye, dame algo de memoria,

75
00:03:09,750 --> 00:03:11,780
y todo lo que tiene que contar
el sistema operativo

76
00:03:11,780 --> 00:03:14,699
es lo que cuando se le pide que para la memoria.

77
00:03:14,699 --> 00:03:16,990
No va a cuidar lo que
que vas a hacer con él,

78
00:03:16,990 --> 00:03:19,786
pero sí es necesario para contar la operación
sistema de lo que a través de malloc.

79
00:03:19,786 --> 00:03:20,286
¿Sí?

80
00:03:20,286 --> 00:03:21,078
>> AUDIENCIA: ¿Cuánto?

81
00:03:21,078 --> 00:03:21,994
DAVID MALAN: ¿Cuánto?

82
00:03:21,994 --> 00:03:25,280
¿Cuánto en bytes, y así, esto, de nuevo,
un ejemplo artificial, es sólo decir,

83
00:03:25,280 --> 00:03:27,360
dame el tamaño de un int.

84
00:03:27,360 --> 00:03:30,550
Ahora, el tamaño de un int
es de cuatro bytes o 32 bits.

85
00:03:30,550 --> 00:03:32,850
Así que esto es sólo una forma de
diciendo, hey, sistema operativo,

86
00:03:32,850 --> 00:03:37,290
dame cuatro bytes de memoria
que puedo usar a mi disposición,

87
00:03:37,290 --> 00:03:40,560
y en concreto, lo que hace
retorno malloc respecto

88
00:03:40,560 --> 00:03:41,795
a ese trozo de cuatro bytes?

89
00:03:41,795 --> 00:03:44,110

90
00:03:44,110 --> 00:03:44,860
AUDIENCIA: Dirección?

91
00:03:44,860 --> 00:03:45,901
DAVID MALAN: la dirección.

92
00:03:45,901 --> 00:03:47,580
La dirección de ese trozo de cuatro bytes.

93
00:03:47,580 --> 00:03:48,190
Exactamente.

94
00:03:48,190 --> 00:03:51,430
Y eso es lo que está almacenado en última instancia,
en x y por eso no lo hacemos realidad

95
00:03:51,430 --> 00:03:55,240
cuidar lo que el número de ese
dirección es, si se trata de OX1 o ox2

96
00:03:55,240 --> 00:03:57,110
o alguna dirección hexadecimal críptica.

97
00:03:57,110 --> 00:03:59,850
Nos preocupamos pictóricamente
que esa variable x es ahora

98
00:03:59,850 --> 00:04:01,630
apuntando a que parte de la memoria.

99
00:04:01,630 --> 00:04:05,570
Así que la flecha representa un puntero o
Más específicamente, una dirección de memoria.

100
00:04:05,570 --> 00:04:09,120
Pero, de nuevo, no nos preocupamos por lo general
lo que esas direcciones son reales.

101
00:04:09,120 --> 00:04:11,780
Ahora, esta línea dice
lo que en términos simples?

102
00:04:11,780 --> 00:04:14,330
Estrella x consigue 42 punto y coma.

103
00:04:14,330 --> 00:04:17,390
¿Qué significa esto?

104
00:04:17,390 --> 00:04:18,200
¿Quieres ir?

105
00:04:18,200 --> 00:04:20,102
No raye el cuello.

106
00:04:20,102 --> 00:04:22,360
>> AUDIENCIA: La dirección de x está en el 42.

107
00:04:22,360 --> 00:04:24,300
>> DAVID MALAN: La dirección de x es a los 42.

108
00:04:24,300 --> 00:04:25,190
No exactamente.

109
00:04:25,190 --> 00:04:28,485
Tan cerca, pero no del todo, porque hay
la estrella que está anteponiendo esta x.

110
00:04:28,485 --> 00:04:29,860
Así que tenemos que ajustar un poco.

111
00:04:29,860 --> 00:04:31,032
¿Sí?

112
00:04:31,032 --> 00:04:36,044
>> AUDIENCIA: El valor que el
puntero x está apuntando es 42.

113
00:04:36,044 --> 00:04:36,710
DAVID MALAN: OK.

114
00:04:36,710 --> 00:04:40,840
El valor que el puntero x es
apuntando a, digamos, serán 42,

115
00:04:40,840 --> 00:04:44,165
o dicho de otra manera, la estrella
x dice, ir a cualquier dirección

116
00:04:44,165 --> 00:04:48,340
está en x, ya sea 1 Oxford
Calle o 33 Oxford Street

117
00:04:48,340 --> 00:04:51,850
o OX1 o OX33, cualquiera que sea
que dirección numérica es,

118
00:04:51,850 --> 00:04:54,380
estrella de x es el desreferencia de x.

119
00:04:54,380 --> 00:04:57,297
Así que ir a esa dirección y
a continuación, poner el número 42 allí.

120
00:04:57,297 --> 00:04:59,380
Así que sería un
manera equivalente a decir eso.

121
00:04:59,380 --> 00:05:01,860
Así que eso es todo fino y después
queremos representar la imagen

122
00:05:01,860 --> 00:05:05,370
de la siguiente manera en la que hemos añadido
la 42 a la parte de las cuatro

123
00:05:05,370 --> 00:05:09,370
bytes en el lado derecho, pero
esta línea era donde las cosas salieron mal

124
00:05:09,370 --> 00:05:11,120
y la cabeza de Binky apareció
en este punto,

125
00:05:11,120 --> 00:05:15,290
porque las cosas malas suceden cuando
que eliminar la referencia de los valores de basura

126
00:05:15,290 --> 00:05:18,210
o eliminar la referencia no válido
punteros, y me dicen que no válido

127
00:05:18,210 --> 00:05:21,020
porque en este punto en el
historia, lo que está dentro de y?

128
00:05:21,020 --> 00:05:24,440
¿Cuál es el valor de y en base
en los últimos pasos?

129
00:05:24,440 --> 00:05:25,360
¿Sí?

130
00:05:25,360 --> 00:05:26,115
¿Que es eso?

131
00:05:26,115 --> 00:05:26,990
>> AUDIENCIA: Una dirección.

132
00:05:26,990 --> 00:05:28,460
DAVID MALAN: Una dirección.

133
00:05:28,460 --> 00:05:31,910
Debe ser una dirección
pero he inicializado él?

134
00:05:31,910 --> 00:05:32,800
Así que no tengo.

135
00:05:32,800 --> 00:05:35,430
Entonces, ¿qué se sabe que es de allí?

136
00:05:35,430 --> 00:05:37,590
Es sólo un cierto valor de la basura.

137
00:05:37,590 --> 00:05:41,500
Podría ser cualquier dirección de cero a
2000000000 si tiene dos gigas de RAM,

138
00:05:41,500 --> 00:05:44,289
o cero a 4 millones de dólares si usted tiene
tiene cuatro gigabytes de RAM.

139
00:05:44,289 --> 00:05:46,080
Es cierto valor de la basura,
pero el problema es

140
00:05:46,080 --> 00:05:48,200
que el sistema operativo,
si no se ha dado

141
00:05:48,200 --> 00:05:51,140
que parte de la memoria específica
que usted está tratando de ir,

142
00:05:51,140 --> 00:05:54,650
es generalmente va a causar lo que
hemos visto como un fallo de segmentación.

143
00:05:54,650 --> 00:05:57,810
Así que, de hecho, cualquiera de ustedes que tienen
luchado en problemas en horario de oficina

144
00:05:57,810 --> 00:06:00,393
o en los problemas que más
generalmente con tratando de averiguar

145
00:06:00,393 --> 00:06:02,150
un fallo de segmentación,
eso significa generalmente

146
00:06:02,150 --> 00:06:05,017
estás tocando un segmento de
la memoria que no debe ser.

147
00:06:05,017 --> 00:06:07,350
Estás tocando de memoria que
el sistema operativo no tiene

148
00:06:07,350 --> 00:06:10,450
le ha permitido tocar, ya sea
por ir demasiado lejos en la matriz

149
00:06:10,450 --> 00:06:12,870
o a partir de ahora, ya sea
es porque usted está tocando

150
00:06:12,870 --> 00:06:14,780
memoria que simplemente es un valor de la basura.

151
00:06:14,780 --> 00:06:18,230
>> Así que hace la estrella x aquí se
tipo de comportamiento indefinido.

152
00:06:18,230 --> 00:06:22,030
Usted nunca debe hacerlo porque las probabilidades
son, el programa sólo va a chocar,

153
00:06:22,030 --> 00:06:24,050
porque usted está diciendo,
ir a esta dirección

154
00:06:24,050 --> 00:06:27,000
y usted no tiene ninguna idea de dónde
que la dirección es en realidad.

155
00:06:27,000 --> 00:06:30,300
Así que el sistema operativo es probable
va a estrellar su programa

156
00:06:30,300 --> 00:06:33,840
como resultado y, de hecho, eso es
lo que pasó allí para Binky.

157
00:06:33,840 --> 00:06:37,210
Así, en última instancia, Binky fijado
este problema con esto.

158
00:06:37,210 --> 00:06:38,909
Así que el programa en sí era defectuoso.

159
00:06:38,909 --> 00:06:41,450
Pero si usted especie de seguir adelante
y ejecutar esta línea en su lugar,

160
00:06:41,450 --> 00:06:45,580
y es igual a x sólo significa lo que sea
dirección es una x, tambien ponerla en y.

161
00:06:45,580 --> 00:06:48,740
>> Y así pictóricamente, tenemos
esta representado con dos flechas

162
00:06:48,740 --> 00:06:51,570
de x y de y apuntando
al mismo lugar.

163
00:06:51,570 --> 00:06:55,760
Así semánticamente, x es igual
a y porque ambos de aquellos

164
00:06:55,760 --> 00:07:00,300
se almacena el mismo
dirección, ergo señalando a 42,

165
00:07:00,300 --> 00:07:04,910
y ahora, cuando dices estrellas
y, vaya a la dirección en y,

166
00:07:04,910 --> 00:07:06,790
esto tiene un efecto secundario interesante.

167
00:07:06,790 --> 00:07:10,320
Así que la dirección en y es el
lo mismo que la dirección de x.

168
00:07:10,320 --> 00:07:15,060
Así que si usted dice ir a la dirección
en y y cambie el valor a 13,

169
00:07:15,060 --> 00:07:17,140
¿quién más se ve afectado?

170
00:07:17,140 --> 00:07:21,100
X es, el punto D, por así decirlo,
deberían verse afectados también.

171
00:07:21,100 --> 00:07:24,340
>> Y, en efecto, cómo Nick hizo este dibujo
en claymation era exactamente eso.

172
00:07:24,340 --> 00:07:28,665
A pesar de que seguimos el puntero
y, que terminó en el mismo lugar,

173
00:07:28,665 --> 00:07:32,780
y por lo que si tuviéramos que imprimir
cabo xo pointee de y,

174
00:07:32,780 --> 00:07:35,720
entonces podríamos ver el valor de 13.

175
00:07:35,720 --> 00:07:37,927
Ahora, digo pointee sea
coherente con el vídeo.

176
00:07:37,927 --> 00:07:39,760
Programadores, a mi
conocimiento, en realidad nunca

177
00:07:39,760 --> 00:07:42,460
decir la palabra pointee,
lo que es puntiaguda

178
00:07:42,460 --> 00:07:44,650
a, pero para la consistencia
con el vídeo, se dan cuenta

179
00:07:44,650 --> 00:07:47,520
eso es todo lo que era
significaba en esa situación.

180
00:07:47,520 --> 00:07:54,190
Así que cualquier pregunta sobre claymation
o punteros o malloc todavía?

181
00:07:54,190 --> 00:07:54,850
¿No?

182
00:07:54,850 --> 00:07:55,470
Correcto.

183
00:07:55,470 --> 00:07:58,560
>> Así que sin más
preámbulos, vamos a echar un vistazo

184
00:07:58,560 --> 00:08:00,700
en donde esto tiene en realidad
ha utilizado durante algún tiempo.

185
00:08:00,700 --> 00:08:03,580
Así que hemos tenido esta biblioteca CS50
eso tiene todas estas funciones.

186
00:08:03,580 --> 00:08:06,810
Hemos utilizado getInt mucho, GetString,
Probablemente GetLongLong anterior

187
00:08:06,810 --> 00:08:09,840
en mi PSet uno o así, pero
lo que ha estado pasando en realidad?

188
00:08:09,840 --> 00:08:12,920
Bueno, vamos a echar un vistazo rápido
debajo de la campana en un programa que

189
00:08:12,920 --> 00:08:17,017
inspira opción te damos la CS50
biblioteca, y de hecho a partir de la semana pasada,

190
00:08:17,017 --> 00:08:18,850
empezamos a tomar las
ruedas de entrenamiento fuera.

191
00:08:18,850 --> 00:08:21,080
Así que esto es ahora ordenadas
de la autopsia de lo

192
00:08:21,080 --> 00:08:23,690
ha estado sucediendo
dentro de la biblioteca CS50,

193
00:08:23,690 --> 00:08:27,250
a pesar de que ahora vamos a empezar a moverse
lejos de él para la mayoría de los programas.

194
00:08:27,250 --> 00:08:29,460
>> Así que este es un programa llamado scanf 0.

195
00:08:29,460 --> 00:08:30,510
Es súper corto.

196
00:08:30,510 --> 00:08:33,909
Sólo tiene estas líneas, pero
introduce una función llamada scanf

197
00:08:33,909 --> 00:08:36,909
que estamos en realidad va a ver en
un momento dentro de la biblioteca CS50,

198
00:08:36,909 --> 00:08:38,600
aunque en una forma ligeramente diferente.

199
00:08:38,600 --> 00:08:41,330
Así que este programa en la línea 16
se declara una variable x.

200
00:08:41,330 --> 00:08:43,150
Así que me dan cuatro bytes para un int.

201
00:08:43,150 --> 00:08:45,750
Ha estado diciendo usuario,
número favor y, a continuación,

202
00:08:45,750 --> 00:08:49,010
esta es una línea interesante que
realidad corbatas juntos la semana pasada

203
00:08:49,010 --> 00:08:49,790
y este.

204
00:08:49,790 --> 00:08:53,230
Scanf, y luego notan que tarda un
cadena de formato, al igual que printf,

205
00:08:53,230 --> 00:08:57,480
% i significa un int, y luego se necesita un
segundo argumento que se ve un poco

206
00:08:57,480 --> 00:08:58,260
funky.

207
00:08:58,260 --> 00:09:01,880
Es signo x, y recordar,
sólo vimos esto una vez pasada semana.

208
00:09:01,880 --> 00:09:03,465
¿Qué signo x representa?

209
00:09:03,465 --> 00:09:06,210

210
00:09:06,210 --> 00:09:08,450
¿Qué hace el símbolo de unión en C?

211
00:09:08,450 --> 00:09:08,950
¿Sí?

212
00:09:08,950 --> 00:09:10,024
>> AUDIENCIA: La dirección de.

213
00:09:10,024 --> 00:09:11,190
DAVID MALAN: La dirección de.

214
00:09:11,190 --> 00:09:13,190
Así que es todo lo contrario
del operador de la estrella,

215
00:09:13,190 --> 00:09:17,270
mientras que el operador de la estrella dice, vaya a
esta dirección, el operador de signo

216
00:09:17,270 --> 00:09:20,280
dice, averiguar el
Dirección de esta variable,

217
00:09:20,280 --> 00:09:23,530
y por lo que esta es la clave, porque
El propósito de scanf en la vida

218
00:09:23,530 --> 00:09:26,320
es escanear el usuario de
entrada desde el teclado,

219
00:09:26,320 --> 00:09:29,970
dependiendo de lo que él o ella
tipos y, a continuación, leer la entrada de ese usuario

220
00:09:29,970 --> 00:09:32,970
en una variable, pero
vio en las últimas dos semanas

221
00:09:32,970 --> 00:09:36,080
que esa función de intercambio que
intentado sin esfuerzo para poner en práctica

222
00:09:36,080 --> 00:09:37,110
se acaba de romper.

223
00:09:37,110 --> 00:09:42,470
Recordemos que con la función de intercambio,
si nos declaramos A y B como enteros,

224
00:09:42,470 --> 00:09:47,040
tuvimos intercambiamos con éxito el
dos variables dentro de canje

225
00:09:47,040 --> 00:09:50,080
al igual que con la leche y zumo de naranja,
pero tan pronto como regresó de intercambio,

226
00:09:50,080 --> 00:09:55,200
cuál fue el resultado con respecto
axey, los valores originales?

227
00:09:55,200 --> 00:09:55,700
Nada.

228
00:09:55,700 --> 00:09:56,200
Sí.

229
00:09:56,200 --> 00:09:59,754
Nada sucedió ese momento, porque
swaps cambian sólo sus copias locales,

230
00:09:59,754 --> 00:10:01,670
que es decir, todo
esta vez, cada vez que hemos

231
00:10:01,670 --> 00:10:04,010
estado pasando en los argumentos
a las funciones, estamos

232
00:10:04,010 --> 00:10:05,939
de paso copias de esos argumentos.

233
00:10:05,939 --> 00:10:07,980
Usted puede hacer con eso
lo que quieras con ellos,

234
00:10:07,980 --> 00:10:10,890
pero van a tener ninguna
efecto sobre los valores originales.

235
00:10:10,890 --> 00:10:13,650
Así que esto es problemático si
quiero tener una función como scanf

236
00:10:13,650 --> 00:10:17,170
en la vida, cuyo propósito es escanear
la entrada del usuario desde el teclado

237
00:10:17,170 --> 00:10:22,010
y luego llenar los espacios en blanco, por lo que
hablar, es decir, dar una variable como x

238
00:10:22,010 --> 00:10:25,410
un valor, porque si yo fuera
que sólo tiene que pasar x para scanf,

239
00:10:25,410 --> 00:10:28,790
si se tiene en cuenta la lógica de la última
semana, scanf puede hacer lo que quiera

240
00:10:28,790 --> 00:10:33,100
con una copia de x, pero no pudo
cambiar permanentemente x menos que demos

241
00:10:33,100 --> 00:10:37,120
scanf un mapa del tesoro, por así decirlo,
donde x marca el lugar, por lo que

242
00:10:37,120 --> 00:10:41,860
pasamos en la dirección de x de manera que
scanf puede ir allí y en realidad el cambio

243
00:10:41,860 --> 00:10:42,920
el valor de x.

244
00:10:42,920 --> 00:10:45,080
Y así, de hecho, todo
que este programa hace

245
00:10:45,080 --> 00:10:53,180
si hago scanf 0, en mi fuente
Directorio de 5m, hacer scanf 0,

246
00:10:53,180 --> 00:10:57,730
punto slash scanf, número
por favor 50, gracias por el 50.

247
00:10:57,730 --> 00:11:01,020
>> Así que no es tan interesante,
pero lo que en verdad sucede

248
00:11:01,020 --> 00:11:04,820
es que tan pronto como me llamo
scanf aquí, el valor de x

249
00:11:04,820 --> 00:11:06,410
se está cambiando de forma permanente.

250
00:11:06,410 --> 00:11:08,335
Ahora, esto parece agradable y
bueno, y de hecho,

251
00:11:08,335 --> 00:11:11,200
parece que realmente no necesitamos
la biblioteca CS50 en todos los más.

252
00:11:11,200 --> 00:11:13,960
Por ejemplo, vamos a correr
esto una vez más aquí.

253
00:11:13,960 --> 00:11:15,750
Permítanme volver a abrirlo por un segundo.

254
00:11:15,750 --> 00:11:20,600
Vamos a tratar un número favor y
en vez de decir 50 como antes,

255
00:11:20,600 --> 00:11:22,810
digamos que no.

256
00:11:22,810 --> 00:11:24,000
OK, eso es un poco raro.

257
00:11:24,000 --> 00:11:25,270
OK.

258
00:11:25,270 --> 00:11:28,680
Y sólo algunas tonterías aquí.

259
00:11:28,680 --> 00:11:31,170
Por lo tanto, no parece
manejar situaciones erróneas.

260
00:11:31,170 --> 00:11:33,620
Así que tenemos que mínimamente inicio
añadiendo un poco de comprobación de errores

261
00:11:33,620 --> 00:11:37,460
para asegurarse de que el usuario tiene
escrito en un número real como 50,

262
00:11:37,460 --> 00:11:40,720
porque las palabras aparentemente mecanografía
no se detecta como problemático,

263
00:11:40,720 --> 00:11:42,020
pero probablemente debería ser.

264
00:11:42,020 --> 00:11:46,450
>> Echemos un vistazo a esta versión ahora que es
mi intento de volver a implementar GetString.

265
00:11:46,450 --> 00:11:48,437
Si scanf tiene todo esto
funcionalidad incorporada,

266
00:11:48,437 --> 00:11:51,270
¿por qué hemos estado coqueteando con ellos
ruedas de entrenamiento como GetString?

267
00:11:51,270 --> 00:11:55,450
Bueno, aquí es tal vez mi propia
versión simple de GetString

268
00:11:55,450 --> 00:12:00,766
por el que hace una semana, podría haber dicho:
dame una cadena y lo llaman búfer.

269
00:12:00,766 --> 00:12:03,390
Hoy, voy a empezar justo
diciendo estrellas char, que, recuerdo,

270
00:12:03,390 --> 00:12:04,400
es sólo sinónimo.

271
00:12:04,400 --> 00:12:06,629
Parece más miedo pero es
exactamente lo mismo.

272
00:12:06,629 --> 00:12:09,420
Así que me dan un buffer variable llamada
eso va a almacenar una cadena,

273
00:12:09,420 --> 00:12:12,780
decir la cadena de usuario por favor,
y luego, al igual que antes,

274
00:12:12,780 --> 00:12:17,760
vamos a tratar de pedir prestado esta lección scanf
% s esta vez y luego pasar en tampón.

275
00:12:17,760 --> 00:12:19,310
Ahora, una comprobación de validez rápido.

276
00:12:19,310 --> 00:12:22,120
Por qué no estoy diciendo
ampersand amortiguar esta vez?

277
00:12:22,120 --> 00:12:25,190

278
00:12:25,190 --> 00:12:26,625
Deducir del ejemplo anterior.

279
00:12:26,625 --> 00:12:28,000
AUDIENCIA: Char estrellas es un puntero.

280
00:12:28,000 --> 00:12:29,920
DAVID MALAN: Exactamente,
porque esta vez, char

281
00:12:29,920 --> 00:12:34,080
estrellas ya es un puntero, una dirección,
por definición de esa estrella estar allí.

282
00:12:34,080 --> 00:12:37,530
Y si scanf espera una dirección,
basta sólo para pasar en tampón.

283
00:12:37,530 --> 00:12:39,260
No necesito decir búfer signo.

284
00:12:39,260 --> 00:12:42,177
Para los curiosos, podría
hacer algo como esto.

285
00:12:42,177 --> 00:12:43,510
Habría significado diferente.

286
00:12:43,510 --> 00:12:47,240
Esto le daría un puntero
a un puntero, que es en realidad

287
00:12:47,240 --> 00:12:50,050
una cosa válida en C, pero para
ahora, vamos a mantenerlo simple

288
00:12:50,050 --> 00:12:51,750
y mantener la historia consistente.

289
00:12:51,750 --> 00:12:54,100
Yo sólo voy a pasar
tampón y eso es correcto.

290
00:12:54,100 --> 00:12:56,487
El problema sin embargo es esto.

291
00:12:56,487 --> 00:12:58,820
Déjame ir adelante y ejecutar este
programa después de la compilación.

292
00:12:58,820 --> 00:13:00,902
Hacer scanf 1.

293
00:13:00,902 --> 00:13:02,610
Maldita sea, mi compilador de
la captura de mi error.

294
00:13:02,610 --> 00:13:04,090
Dame un segundo.

295
00:13:04,090 --> 00:13:05,460
Clang.

296
00:13:05,460 --> 00:13:06,990
Digamos scanf-1.c.

297
00:13:06,990 --> 00:13:10,880

298
00:13:10,880 --> 00:13:11,380
OK.

299
00:13:11,380 --> 00:13:12,720
Allá vamos.

300
00:13:12,720 --> 00:13:14,280
Lo necesito.

301
00:13:14,280 --> 00:13:16,750
Identificación CS50 tiene varios
ajustes de configuración

302
00:13:16,750 --> 00:13:18,280
que protegen contra ti mismo.

303
00:13:18,280 --> 00:13:21,300
Necesitaba desactivar las de
corriendo clang manualmente este momento.

304
00:13:21,300 --> 00:13:22,140
Así cadena favor.

305
00:13:22,140 --> 00:13:25,560
Voy a seguir adelante y escribir
en mi mundo hola favorito.

306
00:13:25,560 --> 00:13:26,490
OK, nulo.

307
00:13:26,490 --> 00:13:27,700
Eso no es lo que he escrito.

308
00:13:27,700 --> 00:13:29,690
Así que es indicativo de
que algo anda mal.

309
00:13:29,690 --> 00:13:33,920
Déjame ir adelante y escribo
en una cadena muy larga.

310
00:13:33,920 --> 00:13:37,210
Gracias por la nula y no sé
si yo voy a ser capaz de estrellarlo.

311
00:13:37,210 --> 00:13:40,240
Vamos a intentar un poco de copia
pegar y ver si esto ayuda.

312
00:13:40,240 --> 00:13:43,290
Sólo tienes que pegar un montón de esto.

313
00:13:43,290 --> 00:13:47,310
Es, definitivamente, una más grande
cadena de lo habitual.

314
00:13:47,310 --> 00:13:51,450
Vamos a realmente escribirlo.

315
00:13:51,450 --> 00:13:51,950
No.

316
00:13:51,950 --> 00:13:52,650
Maldición.

317
00:13:52,650 --> 00:13:53,480
Comando no encontrado.

318
00:13:53,480 --> 00:13:54,550
Así que eso no relacionado.

319
00:13:54,550 --> 00:13:56,440
Eso es porque me pegué
algunos personajes malos,

320
00:13:56,440 --> 00:13:59,780
pero esto resulta que no va a funcionar.

321
00:13:59,780 --> 00:14:03,510
>> Vamos a intentar una vez más, porque
es más divertido si realmente estrellarlo.

322
00:14:03,510 --> 00:14:09,116
Vamos escriba esto y ahora, estoy
va a copiar una cadena muy larga

323
00:14:09,116 --> 00:14:10,990
y ahora vamos a ver si nos
puede chocar esta cosa.

324
00:14:10,990 --> 00:14:14,235
Note que omití espacios y
nuevas líneas y puntos y comas

325
00:14:14,235 --> 00:14:16,035
y todos los personajes de funky.

326
00:14:16,035 --> 00:14:16,535
Intro.

327
00:14:16,535 --> 00:14:21,090

328
00:14:21,090 --> 00:14:22,880
Y ahora la red sólo está siendo lenta.

329
00:14:22,880 --> 00:14:27,460
Sostuve la tecla Comando-V demasiado tiempo, con claridad.

330
00:14:27,460 --> 00:14:28,190
¡Maldición!

331
00:14:28,190 --> 00:14:29,260
Comando no encontrado.

332
00:14:29,260 --> 00:14:29,780
>> OK.

333
00:14:29,780 --> 00:14:32,240
Bueno, el punto es
no obstante, lo siguiente.

334
00:14:32,240 --> 00:14:36,910
Así que lo que realmente está pasando
en la presente declaración

335
00:14:36,910 --> 00:14:39,240
de tampón estrellas Char en la línea 16?

336
00:14:39,240 --> 00:14:41,820
Así que ¿Qué consigo
cuando me declaro un puntero?

337
00:14:41,820 --> 00:14:47,440
Todo lo que estoy haciendo es un valor de cuatro bytes
llamada buffer, pero lo que hay dentro de ella

338
00:14:47,440 --> 00:14:49,540
¿En el momento?

339
00:14:49,540 --> 00:14:50,930
Es sólo un cierto valor de la basura.

340
00:14:50,930 --> 00:14:54,170
Porque cada vez que declara una variable
en C, es sólo un valor de basura,

341
00:14:54,170 --> 00:14:56,220
y estamos empezando a
viaje por esta realidad.

342
00:14:56,220 --> 00:14:59,720
Ahora, cuando te digo scanf,
ir a esta dirección

343
00:14:59,720 --> 00:15:01,520
y poner lo que el usuario escribe.

344
00:15:01,520 --> 00:15:06,400
Si el usuario escribe en hola
mundo, bueno, ¿dónde lo pongo?

345
00:15:06,400 --> 00:15:07,750
Buffer es un valor de la basura.

346
00:15:07,750 --> 00:15:11,510
>> Así que eso es un poco como una flecha
eso está señalando quién sabe dónde.

347
00:15:11,510 --> 00:15:13,880
A lo mejor es que apunta
aquí en mi memoria.

348
00:15:13,880 --> 00:15:16,560
Y así, cuando el usuario
tipos de hola mundo,

349
00:15:16,560 --> 00:15:22,380
el programa trata de poner el
cadena hello world barra invertida 0

350
00:15:22,380 --> 00:15:23,910
en esa parte de la memoria.

351
00:15:23,910 --> 00:15:27,070
Sin embargo, con alta probabilidad, pero
claramente no 100% de probabilidad,

352
00:15:27,070 --> 00:15:30,440
el equipo se va a estrellar a continuación
el programa porque no se trata

353
00:15:30,440 --> 00:15:32,490
la memoria se me permitiera tocar.

354
00:15:32,490 --> 00:15:36,330
Así que en resumen, este programa es
viciado por exactamente eso.

355
00:15:36,330 --> 00:15:38,070
Yo fundamentalmente no estoy haciendo qué?

356
00:15:38,070 --> 00:15:42,366
¿Qué pasos he omitido, al igual que
omitimos con el primer ejemplo de Binky?

357
00:15:42,366 --> 00:15:42,866
¿Sí?

358
00:15:42,866 --> 00:15:43,710
>> AUDIENCIA: asignación de memoria?

359
00:15:43,710 --> 00:15:45,001
>> DAVID MALAN: asignación de memoria.

360
00:15:45,001 --> 00:15:48,400
En realidad no he asignado
cualquier memoria de esa cadena.

361
00:15:48,400 --> 00:15:50,270
Así que podemos arreglar esto en un par de maneras.

362
00:15:50,270 --> 00:15:52,700
Uno, podemos mantenerlo simple
y de hecho, ahora estás

363
00:15:52,700 --> 00:15:55,116
va a comenzar a ver un desdibujamiento
de las líneas entre lo

364
00:15:55,116 --> 00:15:58,520
una matriz es, lo que es una cadena, lo que es un
estrellas char es, lo que es un conjunto de caracteres

365
00:15:58,520 --> 00:15:59,020
es.

366
00:15:59,020 --> 00:16:02,450
He aquí un segundo ejemplo
involucrando cuerdas y notificación

367
00:16:02,450 --> 00:16:05,690
todo lo que he hecho en la línea
16 Es decir, en vez de decir

368
00:16:05,690 --> 00:16:09,530
ese búfer va a ser un char
estrella, un puntero a una parte de la memoria,

369
00:16:09,530 --> 00:16:14,057
Voy a dar muy proactiva
a mí mismo un tampón durante 16 caracteres,

370
00:16:14,057 --> 00:16:16,390
y de hecho, si usted está familiarizado
con el término tampón,

371
00:16:16,390 --> 00:16:20,570
probablemente del mundo de los videos,
donde un video es tampón, tampón,

372
00:16:20,570 --> 00:16:21,175
buffering.

373
00:16:21,175 --> 00:16:22,550
Bueno, ¿cuál es la conexión aquí?

374
00:16:22,550 --> 00:16:24,960
Bueno, Dentro de YouTube
y en el interior de los reproductores de vídeo

375
00:16:24,960 --> 00:16:27,200
en general, es una matriz
eso es más grande que 16.

376
00:16:27,200 --> 00:16:30,340
Puede ser que sea una matriz de tamaño de un
megabyte, tal vez 10 megabytes,

377
00:16:30,340 --> 00:16:34,330
y dentro de esa matriz hace su navegador
descargar un montón de bytes,

378
00:16:34,330 --> 00:16:37,500
un montón de megabytes de
vídeo y el reproductor de vídeo,

379
00:16:37,500 --> 00:16:40,930
YouTube o quien es, comienza
la lectura de los bytes a partir de ese array,

380
00:16:40,930 --> 00:16:43,530
y toda vez que vea la
palabra tampón, tampón,

381
00:16:43,530 --> 00:16:46,350
eso significa que el jugador tiene
llegado al final de esa matriz.

382
00:16:46,350 --> 00:16:50,430
La red es tan lento que no tiene
rellenar la matriz con más bytes

383
00:16:50,430 --> 00:16:55,610
y por lo que está fuera de bits
para mostrar al usuario.

384
00:16:55,610 --> 00:16:59,430
>> Así búfer es un término adecuado aquí en que
es sólo una matriz, un trozo de la memoria.

385
00:16:59,430 --> 00:17:02,530
Y esto lo arreglará
porque resulta que

386
00:17:02,530 --> 00:17:07,410
que se puede tratar como si arrays
son direcciones, a pesar de tampón

387
00:17:07,410 --> 00:17:10,710
es sólo un símbolo, es un
secuencia de caracteres, tampón,

388
00:17:10,710 --> 00:17:14,760
eso es útil para mí, el programador,
usted puede pasar su nombre alrededor

389
00:17:14,760 --> 00:17:17,079
como si se tratara de una
puntero, como si

390
00:17:17,079 --> 00:17:21,000
fueron la dirección de un trozo
de la memoria de 16 caracteres.

391
00:17:21,000 --> 00:17:24,530
Así que eso es decir, puedo pasar
el scanf exactamente esa palabra

392
00:17:24,530 --> 00:17:30,670
y por lo que ahora, si hago este programa,
hacer scanf 2, punto slash scanf 2,

393
00:17:30,670 --> 00:17:35,386
y el tipo de hola mundo,
Enter, que tiempo--

394
00:17:35,386 --> 00:17:37,590
>> Hmm, ¿qué pasó?

395
00:17:37,590 --> 00:17:39,340
Cadena favor.

396
00:17:39,340 --> 00:17:41,430
¿Qué hice mal?

397
00:17:41,430 --> 00:17:43,800
Hola mundo, tampón.

398
00:17:43,800 --> 00:17:44,705
Hola mundo.

399
00:17:44,705 --> 00:17:48,201

400
00:17:48,201 --> 00:17:49,420
Ah, ya sé lo que está haciendo.

401
00:17:49,420 --> 00:17:49,920
OK.

402
00:17:49,920 --> 00:17:51,628
Así que ha leyendo
hasta el primer espacio.

403
00:17:51,628 --> 00:17:55,680
Así que vamos a engañar por un momento y
digo yo sólo quería escribir algo

404
00:17:55,680 --> 00:18:01,408
muy larga como esta es una frase larga
ese es uno, dos, tres, cuatro, cinco,

405
00:18:01,408 --> 00:18:04,420
seis, siete, ocho, nueve,
10, 11, 12, 13, 14, 15, 16.

406
00:18:04,420 --> 00:18:05,300
OK.

407
00:18:05,300 --> 00:18:07,600
De hecho, es una larga condena.

408
00:18:07,600 --> 00:18:10,710
Así que esta frase es
más de 16 caracteres

409
00:18:10,710 --> 00:18:13,670
y así cuando llegué a Enter,
¿Qué va a pasar?

410
00:18:13,670 --> 00:18:16,940
Bueno, en este caso de la
búfer de historia, había declarado

411
00:18:16,940 --> 00:18:22,190
de ser en realidad un array
con 16 caracteres listo para ir.

412
00:18:22,190 --> 00:18:27,426
Así que uno, dos, tres, cuatro, cinco, seis,
siete, ocho, nueve, 10, 11, 12, 13, 14,

413
00:18:27,426 --> 00:18:29,440
15, 16.

414
00:18:29,440 --> 00:18:34,410
Así que 16 caracteres, y ahora, cuando
leído en algo como esto es un largo

415
00:18:34,410 --> 00:18:43,950
frase, lo que va a suceder es
que voy a leer en este es mucho

416
00:18:43,950 --> 00:18:49,660
S-E-N-T-E-N-C-E, sentencia.

417
00:18:49,660 --> 00:18:52,270
>> Así que esto es deliberadamente
una cosa mala que yo

418
00:18:52,270 --> 00:18:55,060
seguir escribiendo más allá de la
límites de mi matriz,

419
00:18:55,060 --> 00:18:56,660
más allá de los límites de mi memoria intermedia.

420
00:18:56,660 --> 00:19:00,100
Yo podría tener suerte y el programa
mantendrá en marcha y no les importa,

421
00:19:00,100 --> 00:19:03,450
pero en términos generales, esta
será hecho estrellar mi programa,

422
00:19:03,450 --> 00:19:06,440
y es un error en mi
codificar el momento me paso

423
00:19:06,440 --> 00:19:08,576
allá de los límites
de esa matriz, porque yo

424
00:19:08,576 --> 00:19:10,450
no sé si es
necesariamente va a estrellar

425
00:19:10,450 --> 00:19:12,120
o si sólo voy a tener suerte.

426
00:19:12,120 --> 00:19:15,750
Así que esto es problemático porque en
este caso, no parece funcionar

427
00:19:15,750 --> 00:19:20,931
y vamos a tentar a la suerte aquí, a pesar de que
el IDE parece tolerar un poco

428
00:19:20,931 --> 00:19:21,430
de--

429
00:19:21,430 --> 00:19:22,040
>> Allá vamos.

430
00:19:22,040 --> 00:19:23,240
Finalmente.

431
00:19:23,240 --> 00:19:26,470
Así que yo soy el único que puede ver esto.

432
00:19:26,470 --> 00:19:29,630
Así que acabo de tener un montón de diversión a escribir
una frase real muy largo

433
00:19:29,630 --> 00:19:32,800
que sin duda superó
16 bytes, porque yo

434
00:19:32,800 --> 00:19:38,050
escrito en este largo de varias líneas loco
frase y, a continuación, darse cuenta de lo que pasó.

435
00:19:38,050 --> 00:19:41,110
El programa trató de imprimirlo
y luego obtuvo un fallo de segmentación

436
00:19:41,110 --> 00:19:44,430
y fallos de segmentación es cuando
sucede algo como esto

437
00:19:44,430 --> 00:19:47,650
y el sistema operativo dice
no, no puede tocar esa memoria.

438
00:19:47,650 --> 00:19:49,570
Vamos a matar
el programa completo.

439
00:19:49,570 --> 00:19:51,180
>> Así que esto parece problemático.

440
00:19:51,180 --> 00:19:54,540
He mejorado el programa mediante el cual
por lo menos tener algo de memoria,

441
00:19:54,540 --> 00:19:58,000
pero esto parece confinar
el GetString función para conseguir

442
00:19:58,000 --> 00:20:00,780
cuerdas de cierta extensión finita 16.

443
00:20:00,780 --> 00:20:04,200
Así que si quieres apoyar ya
sentencias de 16 caracteres,

444
00:20:04,200 --> 00:20:04,880
¿Qué haces?

445
00:20:04,880 --> 00:20:07,970
Bueno, se puede aumentar la
tamaño de este buffer para 32

446
00:20:07,970 --> 00:20:09,190
o eso parece clase de corto.

447
00:20:09,190 --> 00:20:12,260
¿Por qué no simplemente hacer
es 1000, pero hacer retroceder.

448
00:20:12,260 --> 00:20:17,100
¿Cuál es la respuesta intuitiva de
sólo evitar este problema haciendo

449
00:20:17,100 --> 00:20:20,660
mi búfer más grande, como 1.000 caracteres?

450
00:20:20,660 --> 00:20:23,470
Mediante la implementación de GetString de esta manera.

451
00:20:23,470 --> 00:20:27,130
Lo que es bueno o malo aquí?

452
00:20:27,130 --> 00:20:28,033
¿Sí?

453
00:20:28,033 --> 00:20:30,574
AUDIENCIA: Si enlaza una gran cantidad
del espacio y no lo utiliza,

454
00:20:30,574 --> 00:20:33,500
entonces no se puede reasignar ese espacio.

455
00:20:33,500 --> 00:20:34,500
DAVID MALAN: Por supuesto.

456
00:20:34,500 --> 00:20:38,480
Es un desperdicio medida en que si no lo hace
realmente necesita 900 de esos bytes

457
00:20:38,480 --> 00:20:41,057
y sin embargo, usted está pidiendo
1.000 en total, de todos modos,

458
00:20:41,057 --> 00:20:44,140
usted está consumiendo más memoria
el ordenador del usuario que usted necesita,

459
00:20:44,140 --> 00:20:45,740
y después de todo, algunos de
ya has encontrado

460
00:20:45,740 --> 00:20:47,620
en la vida que cuando estás
corriendo un montón de programas

461
00:20:47,620 --> 00:20:50,470
y están comiendo mucha memoria,
en realidad esto puede afectar al rendimiento

462
00:20:50,470 --> 00:20:52,220
y la experiencia del usuario
en la computadora.

463
00:20:52,220 --> 00:20:56,090
Así que eso es una especie de solución perezoso,
a ciencia cierta, y por el contrario,

464
00:20:56,090 --> 00:21:00,140
que no sólo es un desperdicio, qué problema
sigue siendo, incluso si hago mi búfer

465
00:21:00,140 --> 00:21:02,100
1000?

466
00:21:02,100 --> 00:21:02,600
¿Sí?

467
00:21:02,600 --> 00:21:04,475
>> AUDIENCIA: La cadena es la longitud de 1.001.

468
00:21:04,475 --> 00:21:05,350
DAVID MALAN: Exactamente.

469
00:21:05,350 --> 00:21:08,280
Si la cadena es la longitud de 1001,
usted tiene el mismo problema,

470
00:21:08,280 --> 00:21:10,705
y con mi argumento, lo haría
justo en ese momento que sea 2000,

471
00:21:10,705 --> 00:21:12,830
pero usted no sabe en
avanzar en lo grande que debe ser,

472
00:21:12,830 --> 00:21:16,890
y, sin embargo, tengo que compilar mi programa
antes de dejar que la gente usa y descarga

473
00:21:16,890 --> 00:21:17,390
ello.

474
00:21:17,390 --> 00:21:21,490
Así que este es exactamente el tipo de
cosas que los intentos de la biblioteca CS50

475
00:21:21,490 --> 00:21:24,750
para ayudarnos con y estaremos solamente vista
En algunas de la implementación subyacente

476
00:21:24,750 --> 00:21:29,790
aquí, pero esto es CS50 dot C. Este
es el archivo que ha estado en CS50 IDE

477
00:21:29,790 --> 00:21:31,420
todas estas semanas que ha estado usando.

478
00:21:31,420 --> 00:21:34,280
Es pre-compilado y que ha
estado utilizando de forma automática

479
00:21:34,280 --> 00:21:38,780
por la naturaleza de tener el
lanzarse L bandera CS50 con estrépito,

480
00:21:38,780 --> 00:21:42,300
pero si me desplazo hacia abajo a través de todos
estas funciones, aquí está GetString,

481
00:21:42,300 --> 00:21:44,636
y sólo para darle un
muestra de lo que está pasando,

482
00:21:44,636 --> 00:21:46,760
vamos a echar un vistazo rápido a
la relativa complejidad.

483
00:21:46,760 --> 00:21:48,870
No es un super largo
función, pero no lo hicimos

484
00:21:48,870 --> 00:21:52,530
hay que pensar seriamente en todo
cómo hacer para conseguir cadenas.

485
00:21:52,530 --> 00:21:55,660
>> Así que aquí está mi memoria intermedia y yo
aparentemente inicializarlo en null.

486
00:21:55,660 --> 00:21:57,990
Esto, por supuesto, es el
lo mismo que la estrella char,

487
00:21:57,990 --> 00:22:00,585
pero decidí en
la aplicación de la biblioteca CS50

488
00:22:00,585 --> 00:22:02,460
que si vamos a
ser completamente dinámico,

489
00:22:02,460 --> 00:22:05,770
No sé de antemano lo grande de una
usuarios de cuerda van a querer conseguir.

490
00:22:05,770 --> 00:22:08,140
Así que voy a empezar
con sólo una cadena vacía

491
00:22:08,140 --> 00:22:11,507
y yo voy a construir la mayor cantidad
la memoria, ya que necesito para adaptarse a la cadena de usuario

492
00:22:11,507 --> 00:22:13,340
y si no tengo
suficiente, voy a preguntar

493
00:22:13,340 --> 00:22:15,010
el sistema operativo para más memoria.

494
00:22:15,010 --> 00:22:17,510
Voy a mover su cadena
en un pedazo más grande de la memoria

495
00:22:17,510 --> 00:22:21,847
y yo voy a soltar o liberar el
insuficientemente gran parte de la memoria

496
00:22:21,847 --> 00:22:23,680
y sólo vamos
para hacer esto de forma iterativa.

497
00:22:23,680 --> 00:22:25,570
>> Así que una rápida mirada,
aquí es sólo una variable

498
00:22:25,570 --> 00:22:28,780
con la que me voy a llevar un registro
de la capacidad de mi buffer.

499
00:22:28,780 --> 00:22:30,071
¿Cuántos bytes puedo encajar?

500
00:22:30,071 --> 00:22:32,070
Aquí hay una variable n con
que yo voy a seguir

501
00:22:32,070 --> 00:22:36,200
un registro de cuántos bytes son realmente en
el tampón o que el usuario ha escrito.

502
00:22:36,200 --> 00:22:39,900
Si no has visto esto antes,
puede especificar que una variable como un int

503
00:22:39,900 --> 00:22:46,370
no está firmado, que como su nombre indica,
significa que es no negativo, y por qué lo haría

504
00:22:46,370 --> 00:22:50,590
Yo nunca quiero molestar especificando
que un int no es sólo un int,

505
00:22:50,590 --> 00:22:52,540
pero es un int sin firmar?

506
00:22:52,540 --> 00:22:55,064
Es un int no negativo.

507
00:22:55,064 --> 00:22:56,355
¿Qué hace el [inaudible] significa?

508
00:22:56,355 --> 00:22:58,910
>> AUDIENCIA: Se describe una cantidad
de memoria que puede ser [inaudible].

509
00:22:58,910 --> 00:22:59,660
>> DAVID MALAN: Sí.

510
00:22:59,660 --> 00:23:03,710
Así que si digo sin firmar, esto es en realidad
dándole un bit de memoria adicional

511
00:23:03,710 --> 00:23:07,440
y parece un poco tonto, pero si
tienen un bit de memoria adicional, que

512
00:23:07,440 --> 00:23:09,940
significa que tiene dos veces más
valores que puede representar,

513
00:23:09,940 --> 00:23:11,570
porque puede ser un 0 o un 1.

514
00:23:11,570 --> 00:23:14,660
Así que por defecto, un int puede ser más o menos
negativo de 2 mil millones hasta el final

515
00:23:14,660 --> 00:23:16,030
hasta positivo 2000000000.

516
00:23:16,030 --> 00:23:18,540
Esos son grandes rangos, pero
es todavía tipo de desperdicio

517
00:23:18,540 --> 00:23:21,280
si sólo se preocupan por
tamaños, que acaba de forma intuitiva

518
00:23:21,280 --> 00:23:24,620
debe ser no negativo o
positivo o 0, pues bien,

519
00:23:24,620 --> 00:23:28,884
¿por qué estás perdiendo 2000000000
posibles valores para los números negativos

520
00:23:28,884 --> 00:23:30,300
si nunca vas a usarlos?

521
00:23:30,300 --> 00:23:35,350
Así diciendo sin firmar, ahora mi int puede
estar entre 0 y aproximadamente 4 mil millones.

522
00:23:35,350 --> 00:23:39,280
>> Así que aquí es simplemente un int C por razones
no vamos a entrar en un momento como

523
00:23:39,280 --> 00:23:42,280
a eso que es un int en lugar
de un char, pero aquí es

524
00:23:42,280 --> 00:23:44,630
la esencia de lo que está pasando
en adelante, y algunos de ustedes

525
00:23:44,630 --> 00:23:48,340
podría estar usando, por ejemplo, el
función fgetc incluso en PSet de cuatro

526
00:23:48,340 --> 00:23:51,580
oa partir de entonces, ya veremos que
de nuevo en un problema conjunto de cinco,

527
00:23:51,580 --> 00:23:55,410
fgetc es agradable porque como su nombre
clase de, clase de arcanamente sugiere,

528
00:23:55,410 --> 00:23:57,940
es una función que
consigue un personaje y así,

529
00:23:57,940 --> 00:24:00,690
lo que es fundamentalmente diferente
acerca de lo que estamos haciendo en GetString

530
00:24:00,690 --> 00:24:03,110
es que no estamos utilizando
scanf de la misma manera.

531
00:24:03,110 --> 00:24:07,550
Sólo estamos arrastrándose a lo largo paso a paso
más de lo que el usuario ha tecleado,

532
00:24:07,550 --> 00:24:10,970
porque siempre podemos asignar un solo
char, por lo que siempre se puede de manera segura

533
00:24:10,970 --> 00:24:15,599
mirar uno carbón a la vez, y
la magia comienza a suceder aquí.

534
00:24:15,599 --> 00:24:17,890
Voy a desplazarse hacia abajo para
el medio de esta función

535
00:24:17,890 --> 00:24:20,360
sólo para presentar brevemente esta función.

536
00:24:20,360 --> 00:24:22,670
Al igual que hay un
función malloc, hay

537
00:24:22,670 --> 00:24:27,740
una función realloc donde realloc
le permite reasignar una parte de la memoria

538
00:24:27,740 --> 00:24:29,570
y hacerlo más grande o más pequeño.

539
00:24:29,570 --> 00:24:33,060
En tanto cuento y con
una ola de mi mano para hoy,

540
00:24:33,060 --> 00:24:35,620
saber que lo GetString
está haciendo es que es una especie

541
00:24:35,620 --> 00:24:39,720
del arte de magia de crecer o
la reducción de la memoria intermedia como el usuario

542
00:24:39,720 --> 00:24:41,440
tipos en su cadena.

543
00:24:41,440 --> 00:24:43,962
>> Así que si el usuario escribe una
cadena corta, este código

544
00:24:43,962 --> 00:24:45,920
sólo se asigna suficiente
memoria para adaptarse a la cadena.

545
00:24:45,920 --> 00:24:48,086
Si el usuario mantiene la tipificación
como lo hice una y otra vez

546
00:24:48,086 --> 00:24:50,330
y otra vez, bueno, si el
búfer de un principio tan grande

547
00:24:50,330 --> 00:24:53,310
y el programa se da cuenta, a
Espera un minuto, estoy fuera del espacio,

548
00:24:53,310 --> 00:24:55,410
que va a duplicar
el tamaño del búfer

549
00:24:55,410 --> 00:24:59,110
y luego doblar el tamaño de la memoria intermedia
y el código que hace la duplicación,

550
00:24:59,110 --> 00:25:03,170
si miramos desde aquí, es
sólo por esta inteligente de una sola línea.

551
00:25:03,170 --> 00:25:06,830
Es posible que no haya visto esta sintaxis
antes, pero si dices estrellas es igual,

552
00:25:06,830 --> 00:25:10,470
este es el mismo que
diciendo tiempos capacidad 2.

553
00:25:10,470 --> 00:25:13,390
Por lo tanto, sólo sigue duplicando
la capacidad de la memoria intermedia

554
00:25:13,390 --> 00:25:17,480
y luego contando realloc para dar
sí que mucho más memoria.

555
00:25:17,480 --> 00:25:19,720
>> Ahora, como un aparte, hay
son otras funciones en aquí

556
00:25:19,720 --> 00:25:23,680
que no vamos a mirar en detalle
aparte de mostrar en getInt,

557
00:25:23,680 --> 00:25:26,150
usamos GetString en getInt.

558
00:25:26,150 --> 00:25:28,192
Comprobamos que no es
null, que, recuerdo,

559
00:25:28,192 --> 00:25:30,400
es el valor especial que
significa algo salió mal.

560
00:25:30,400 --> 00:25:31,233
Estamos fuera de la memoria.

561
00:25:31,233 --> 00:25:32,310
Mejor comprobar eso.

562
00:25:32,310 --> 00:25:33,710
Y volvemos un valor centinela.

563
00:25:33,710 --> 00:25:37,850
Pero te remito a los comentarios en cuanto a
por qué y luego usamos ese primo de scanf

564
00:25:37,850 --> 00:25:42,100
llama sscanf y resulta
que scanf sscanf, o cadena,

565
00:25:42,100 --> 00:25:45,310
le permite echar un vistazo a la línea que
el usuario ha escrito y te deja

566
00:25:45,310 --> 00:25:49,610
analizarla esencial y lo que estoy
haciendo aquí es que estoy diciendo sscanf,

567
00:25:49,610 --> 00:25:54,440
analizar lo que el usuario tiene
escrito en y asegúrese de% i,

568
00:25:54,440 --> 00:25:59,250
no es un número entero en ella, y no lo haremos
entrar en la actualidad exactamente por qué también hay

569
00:25:59,250 --> 00:26:03,760
un% c aquí, pero que en pocas palabras permite
nos permite detectar si el usuario ha escrito

570
00:26:03,760 --> 00:26:06,050
en algo falso después del número.

571
00:26:06,050 --> 00:26:11,766
Así que la razón por la que getInt y GetString
decirle a reintentar, reintentar, vuelva a intentarlo

572
00:26:11,766 --> 00:26:13,640
es porque de todos
que el código que hemos escrito,

573
00:26:13,640 --> 00:26:17,900
Es una especie de mirar a la entrada del usuario
en asegurarse de que es totalmente numérico

574
00:26:17,900 --> 00:26:21,700
o se trata de un flotante real
valor de puntos o similar,

575
00:26:21,700 --> 00:26:24,233
dependiendo de qué valor
función que está utilizando.

576
00:26:24,233 --> 00:26:25,060
>> ¡Menos mal.

577
00:26:25,060 --> 00:26:25,710
OK.

578
00:26:25,710 --> 00:26:27,592
Eso fue un bocado
pero el punto aquí es

579
00:26:27,592 --> 00:26:29,550
que la razón por la que tuvimos
esas ruedas de capacitación sobre

580
00:26:29,550 --> 00:26:32,880
es porque en el nivel más bajo,
hay tantas cosas que

581
00:26:32,880 --> 00:26:35,674
puede salir mal que queríamos
para manejar de forma preventiva

582
00:26:35,674 --> 00:26:38,090
esas cosas ciertamente en el
primeras semanas de la clase,

583
00:26:38,090 --> 00:26:42,230
pero ahora con PSet cuatro y cinco y PSet
allá va a ver que es más hasta

584
00:26:42,230 --> 00:26:45,570
usted, pero también eres más capaz
de resolver ese tipo de problemas

585
00:26:45,570 --> 00:26:47,180
tú mismo.

586
00:26:47,180 --> 00:26:51,770
¿Tiene preguntas sobre GetString o getInt?

587
00:26:51,770 --> 00:26:52,630
¿Sí?

588
00:26:52,630 --> 00:26:55,130
>> AUDIENCIA: ¿Por qué el doble
la capacidad de la memoria intermedia

589
00:26:55,130 --> 00:26:57,630
en lugar de simplemente aumentar
por la cantidad exacta?

590
00:26:57,630 --> 00:26:58,100
>> DAVID MALAN: Buena pregunta.

591
00:26:58,100 --> 00:27:00,474
¿Por qué deberíamos duplicar la capacidad
de la memoria intermedia en oposición

592
00:27:00,474 --> 00:27:02,800
sólo aumentarla
por algún valor constante?

593
00:27:02,800 --> 00:27:03,900
Fue una decisión de diseño.

594
00:27:03,900 --> 00:27:08,590
Nos decidimos que ya que tiende a
ser un poco caro en cuanto a tiempo de pedir

595
00:27:08,590 --> 00:27:10,440
el sistema operativo
para la memoria, no lo hicimos

596
00:27:10,440 --> 00:27:13,210
quiere terminar metiendo
una situación para las cadenas grandes

597
00:27:13,210 --> 00:27:14,960
que estábamos pidiendo
el OS y otra vez

598
00:27:14,960 --> 00:27:17,500
y otra vez y otra vez en
sucesión rápida para la memoria.

599
00:27:17,500 --> 00:27:20,387
Así que decidimos, algo
arbitrariamente pero esperamos razonablemente,

600
00:27:20,387 --> 00:27:22,720
que, ya sabes qué, vamos a
tratar de salir adelante de nosotros mismos

601
00:27:22,720 --> 00:27:25,520
y simplemente seguir doblando de manera que
minimizamos la cantidad de veces

602
00:27:25,520 --> 00:27:29,010
tenemos que llamar a malloc o
realloc, pero un fallo total de

603
00:27:29,010 --> 00:27:31,820
llamar a falta de saber
lo que los usuarios podrían querer escribir.

604
00:27:31,820 --> 00:27:33,600
Ambas formas pueden ser discutibles.

605
00:27:33,600 --> 00:27:35,430
Podría decirse que buena.

606
00:27:35,430 --> 00:27:39,240
>> Así que vamos a echar un vistazo a un par
de otros efectos secundarios de la memoria,

607
00:27:39,240 --> 00:27:41,610
cosas que pueden salir mal
y herramientas que puede

608
00:27:41,610 --> 00:27:43,880
utilizar para capturar este tipo de errores.

609
00:27:43,880 --> 00:27:47,800
Resulta que todos ustedes, a pesar de que
check50 no le ha dicho tanto,

610
00:27:47,800 --> 00:27:50,050
se han escrito con errores
código desde la semana uno,

611
00:27:50,050 --> 00:27:53,630
incluso si todas las pruebas son check50
pasaba, e incluso si usted y su TF

612
00:27:53,630 --> 00:27:56,010
son super seguros de que
el código funciona como está previsto.

613
00:27:56,010 --> 00:27:59,190
El código ha sido buggy o
viciado en que todos ustedes,

614
00:27:59,190 --> 00:28:02,540
en el uso de la biblioteca CS50,
han sido fugas de memoria.

615
00:28:02,540 --> 00:28:06,040
Usted ha estado pidiendo el sistema operativo
para la memoria en la mayoría de los programas

616
00:28:06,040 --> 00:28:08,850
usted ha escrito, pero tienes
En realidad nunca dada vuelta.

617
00:28:08,850 --> 00:28:12,110
Usted ha llamado GetString
y getInt y GetFloat,

618
00:28:12,110 --> 00:28:15,270
pero con GetString, tienes
Nunca llamada unGetString o Dar

619
00:28:15,270 --> 00:28:19,890
Posterior de la secuencia o similares, pero hemos visto
GetString que hace asignar memoria

620
00:28:19,890 --> 00:28:22,810
por medio de malloc o este
realloc función, que es sólo

621
00:28:22,810 --> 00:28:25,670
muy similar en espíritu,
y, sin embargo, hemos sido

622
00:28:25,670 --> 00:28:28,629
preguntar al sistema operativo para
la memoria y la memoria una y otra vez

623
00:28:28,629 --> 00:28:29,670
pero nunca darle la espalda.

624
00:28:29,670 --> 00:28:33,550
>> Ahora, como un aparte, resulta que
cuando un programa se cierra, toda la memoria

625
00:28:33,550 --> 00:28:34,870
se libera automáticamente.

626
00:28:34,870 --> 00:28:36,150
Así que no ha sido un gran negocio.

627
00:28:36,150 --> 00:28:38,590
No va a romper el
IDE o cosas más despacio,

628
00:28:38,590 --> 00:28:40,670
Pero cuando los programas hacen
generalmente perder memoria

629
00:28:40,670 --> 00:28:42,170
y se están ejecutando durante mucho tiempo.

630
00:28:42,170 --> 00:28:45,640
Si alguna vez has visto la pequeña estúpida
pelota de playa en Mac OS o el reloj de arena

631
00:28:45,640 --> 00:28:51,160
en Windows, donde es una especie de
la ralentización o el pensamiento o el pensamiento

632
00:28:51,160 --> 00:28:53,770
o realmente comienza
para frenar a un rastreo,

633
00:28:53,770 --> 00:28:56,960
muy posiblemente podría ser
el resultado de una pérdida de memoria.

634
00:28:56,960 --> 00:28:59,970
Los programadores que escribieron
el software que está utilizando

635
00:28:59,970 --> 00:29:03,570
pedir al sistema operativo para la memoria
cada pocos minutos, cada hora.

636
00:29:03,570 --> 00:29:05,570
Pero si se está ejecutando la
software, incluso si es

637
00:29:05,570 --> 00:29:08,680
minimizado en su ordenador
por horas o días y días,

638
00:29:08,680 --> 00:29:11,980
se puede preguntar por más y más
la memoria y la realidad nunca usarlo

639
00:29:11,980 --> 00:29:15,180
y por lo que su código podría ser, o
programas podrían tener fugas de memoria,

640
00:29:15,180 --> 00:29:18,350
y si usted comienza a perder memoria,
hay menos memoria para otros programas,

641
00:29:18,350 --> 00:29:21,220
y el efecto es
frenar todo.

642
00:29:21,220 --> 00:29:23,600
>> Ahora, esto es, de lejos, uno de
los programas más atroces

643
00:29:23,600 --> 00:29:26,350
usted tendrá la oportunidad
para funcionar en la medida CS50

644
00:29:26,350 --> 00:29:31,650
como su salida es aún más esotérico que
sonido metálico de o hacer de o cualquiera de los comandos

645
00:29:31,650 --> 00:29:35,930
programas de línea nos hemos quedado antes, pero
afortunadamente, incrustado en su salida

646
00:29:35,930 --> 00:29:39,810
es algunos consejos muy útiles que
será útil tanto para PSet de cuatro

647
00:29:39,810 --> 00:29:41,510
o seguramente PConfigure cinco.

648
00:29:41,510 --> 00:29:44,250
Así valgrind es una herramienta
que se puede utilizar para buscar

649
00:29:44,250 --> 00:29:46,930
que no haya fugas de memoria en su programa.

650
00:29:46,930 --> 00:29:48,570
Es relativamente fácil de ejecutar.

651
00:29:48,570 --> 00:29:51,420
Ejecuta valgrind y luego, incluso
aunque es un poco prolijo,

652
00:29:51,420 --> 00:29:54,440
tablero comprobación de fugas tablero
iguales por completo, y luego puntear

653
00:29:54,440 --> 00:29:56,320
tala y el nombre de su programa.

654
00:29:56,320 --> 00:30:00,010
Así valgrind entonces ejecutar el programa
y al final de su programa

655
00:30:00,010 --> 00:30:02,240
corriendo antes de que cierra y
le da otro aviso,

656
00:30:02,240 --> 00:30:04,980
que va a analizar su
programa mientras se ha estado corriendo

657
00:30:04,980 --> 00:30:07,740
y dices que has de tener fugas
cualquier memoria y mejor aún,

658
00:30:07,740 --> 00:30:10,610
tocaste memoria que
no pertenecen a usted?

659
00:30:10,610 --> 00:30:13,700
No puede coger todo, pero es
bastante bueno en la captura de la mayoría de las cosas.

660
00:30:13,700 --> 00:30:19,700
>> Así que aquí está un ejemplo de mi haber corrido
este programa, que tiene plazo valgrind,

661
00:30:19,700 --> 00:30:21,470
en un programa llamado
memoria, y me voy

662
00:30:21,470 --> 00:30:24,730
para resaltar las líneas que son
en última instancia, de interés para nosotros.

663
00:30:24,730 --> 00:30:27,690
Así que incluso hay más distracciones
que he eliminado de la diapositiva.

664
00:30:27,690 --> 00:30:30,930
Pero vamos a ver lo que este
programa es capaz de decirnos.

665
00:30:30,930 --> 00:30:34,800
Es capaz de decirnos cosas
como escritura no válida de tamaño 4.

666
00:30:34,800 --> 00:30:38,020
En otras palabras, si se toca la memoria,
específicamente 4 bytes de memoria

667
00:30:38,020 --> 00:30:40,350
que usted no debe tener,
valgrind le puede decir eso.

668
00:30:40,350 --> 00:30:41,660
Escritura no válida de tamaño 4.

669
00:30:41,660 --> 00:30:43,640
Tocaste cuatro bytes
que no debería tener.

670
00:30:43,640 --> 00:30:44,840
¿Dónde se hace eso?

671
00:30:44,840 --> 00:30:45,900
Esta es la belleza.

672
00:30:45,900 --> 00:30:50,000
La línea de puntos c Memoria 21 es donde se
jodido y es por eso que es útil.

673
00:30:50,000 --> 00:30:53,410
Al igual que el BGF, puede ayudar
señalarle en el error real.

674
00:30:53,410 --> 00:30:57,170
>> Ahora, éste es un poco más
detallado, si no confuso.

675
00:30:57,170 --> 00:31:01,307
40 Bytes 1 bloques son definitivamente
perdido en el registro de la pérdida 1 de 1.

676
00:31:01,307 --> 00:31:02,140
¿Que significa eso?

677
00:31:02,140 --> 00:31:05,920
Bueno, sólo significa que usted pidió
40 bytes y nunca se dio vuelta.

678
00:31:05,920 --> 00:31:08,930
Usted llamó malloc o llamó
GetString y el sistema operativo

679
00:31:08,930 --> 00:31:12,450
que 40 bytes, pero nunca se dio
liberado o liberada esa memoria,

680
00:31:12,450 --> 00:31:15,400
y para ser justos, nunca hemos mostramos
cómo devuelves la memoria.

681
00:31:15,400 --> 00:31:17,910
Resulta que hay un súper
función simple llamada gratuita.

682
00:31:17,910 --> 00:31:21,170
Toma un argumento, la cosa
desea liberar o dar vuelta,

683
00:31:21,170 --> 00:31:23,430
pero 40 bytes, por lo visto,
en este programa

684
00:31:23,430 --> 00:31:27,300
se han perdido en la línea
20 de la memoria dot c.

685
00:31:27,300 --> 00:31:28,650
>> Así que vamos a ver este programa.

686
00:31:28,650 --> 00:31:31,020
Es super inútil.

687
00:31:31,020 --> 00:31:33,980
Sólo demuestra
este error en particular.

688
00:31:33,980 --> 00:31:34,920
Así que vamos a echar un vistazo.

689
00:31:34,920 --> 00:31:39,920
He aquí los principales y principales, aviso, llamadas
una función llamada regresa f cuando.

690
00:31:39,920 --> 00:31:41,550
Así que no es tan interesante.

691
00:31:41,550 --> 00:31:42,664
¿Qué hacer f?

692
00:31:42,664 --> 00:31:44,330
Note que no se molestó con un prototipo.

693
00:31:44,330 --> 00:31:46,520
Quería mantener el código
el mínimo posible.

694
00:31:46,520 --> 00:31:49,530
Así que puse f anterior principal y
eso está bien, sin duda,

695
00:31:49,530 --> 00:31:51,500
para programas cortos como este.

696
00:31:51,500 --> 00:31:56,910
Así que f no devuelve nada y hace
No tome nada, pero que sí hace esto.

697
00:31:56,910 --> 00:31:59,620
Declara, al igual que
en el ejemplo de Binky,

698
00:31:59,620 --> 00:32:02,682
un puntero llamado X que va
para almacenar la dirección de un int.

699
00:32:02,682 --> 00:32:03,890
Así que ese es el lado izquierdo.

700
00:32:03,890 --> 00:32:07,230
En Inglés, ¿cuál es la
lado derecho haciendo?

701
00:32:07,230 --> 00:32:09,770
Cualquier persona?

702
00:32:09,770 --> 00:32:13,665
¿Qué es este haciendo por nosotros?

703
00:32:13,665 --> 00:32:14,651
¿Sí?

704
00:32:14,651 --> 00:32:16,623
>> AUDIENCIA: [inaudible]
veces el tamaño de un int

705
00:32:16,623 --> 00:32:19,175
que es 10 veces mayor que [inaudible]

706
00:32:19,175 --> 00:32:20,800
DAVID MALAN: Bien y permítanme resumir.

707
00:32:20,800 --> 00:32:25,480
Así asignar suficiente espacio para 10 enteros
o 10, ¿cuál es el tamaño de un int,

708
00:32:25,480 --> 00:32:29,340
es cuatro bytes, por lo que 10 veces 4 es
40, por lo que a mano derecha que tengo

709
00:32:29,340 --> 00:32:33,930
resaltado es darme 40 bytes y
almacenar la dirección del primer byte

710
00:32:33,930 --> 00:32:34,940
en x.

711
00:32:34,940 --> 00:32:38,380
Y ahora, por último, y aquí es donde
este programa está libre de errores, lo que es

712
00:32:38,380 --> 00:32:41,540
mal con la línea 21 basa en que la lógica?

713
00:32:41,540 --> 00:32:45,197

714
00:32:45,197 --> 00:32:46,280
¿Qué hay de malo en la línea 21?

715
00:32:46,280 --> 00:32:46,780
¿Sí?

716
00:32:46,780 --> 00:32:49,550
AUDIENCIA: Usted no puede
índice en x [inaudible].

717
00:32:49,550 --> 00:32:50,300
DAVID MALAN: Sí.

718
00:32:50,300 --> 00:32:52,270
Que no debería índice en x el estilo.

719
00:32:52,270 --> 00:32:53,850
Así sintácticamente, eso está bien.

720
00:32:53,850 --> 00:32:56,990
Lo bueno es, al igual que
puede tratar el nombre de una matriz

721
00:32:56,990 --> 00:33:01,080
como si fuera un puntero, de manera similar
puede tratar a un puntero como si fuera

722
00:33:01,080 --> 00:33:06,425
una matriz, y así puedo sintácticamente
decir x soporte de algo, x soporte de i,

723
00:33:06,425 --> 00:33:07,800
pero el 10 es problemática.

724
00:33:07,800 --> 00:33:09,096
¿Por qué?

725
00:33:09,096 --> 00:33:10,910
>> AUDIENCIA: Debido a que no hay dentro.

726
00:33:10,910 --> 00:33:12,390
>> DAVID MALAN: No es
dentro de esa parte de la memoria.

727
00:33:12,390 --> 00:33:15,306
¿Qué es el valor más grande que debe
estar poniendo en esos corchetes?

728
00:33:15,306 --> 00:33:16,870
9, del 0 al 9.

729
00:33:16,870 --> 00:33:18,160
Debido a cero de indexación.

730
00:33:18,160 --> 00:33:20,190
Así que de 0 a 9 estaría bien.

731
00:33:20,190 --> 00:33:23,960
Soporte de 10 no es bueno y
pero, recordar, sin embargo, cada vez que

732
00:33:23,960 --> 00:33:27,017
Me parece que tratar de hacer CS50 IDE
accidente escribiendo en valores falsos,

733
00:33:27,017 --> 00:33:29,100
no siempre coopera,
y, de hecho, a menudo

734
00:33:29,100 --> 00:33:31,460
tener suerte sólo porque el
sistema operativo no

735
00:33:31,460 --> 00:33:35,467
cuenta de que muy ligeramente
pasar algún trozo de la memoria,

736
00:33:35,467 --> 00:33:38,300
porque usted se quedó dentro técnicamente
su segmento, pero más sobre esto

737
00:33:38,300 --> 00:33:40,940
en una clase de sistemas operativos,
y así algo como esto

738
00:33:40,940 --> 00:33:43,000
podría muy fácilmente pasar desapercibida.

739
00:33:43,000 --> 00:33:48,120
Su programa nunca va a estrellar
consistentemente pero tal vez en un rato.

740
00:33:48,120 --> 00:33:50,610
>> Y así vamos a tratar valgrind
en esto, y aquí está

741
00:33:50,610 --> 00:33:52,870
donde vamos a llegar abrumado
por la salida momentáneamente.

742
00:33:52,870 --> 00:34:00,810
Así que la memoria de verificación de fugas valgrind
es igual a la memoria barra de puntos completa.

743
00:34:00,810 --> 00:34:03,040
Y he aquí por qué te lo prometo
esto podría abrumar.

744
00:34:03,040 --> 00:34:05,700
Esto es lo que valgrind, esto es lo
un programador, algunos años-

745
00:34:05,700 --> 00:34:08,469
decidió que sería una buena idea
para la salida a parecer.

746
00:34:08,469 --> 00:34:09,750
Así que vamos a hacer sentido de esto.

747
00:34:09,750 --> 00:34:13,120
Así que todo el camino a la izquierda
lado por ninguna buena razón

748
00:34:13,120 --> 00:34:16,620
es el ID de proceso del programa
acabamos de correr, el identificador único

749
00:34:16,620 --> 00:34:18,030
para el programa que acabamos de corrimos.

750
00:34:18,030 --> 00:34:19,738
Hemos suprimido que desde
la diapositiva, pero hay

751
00:34:19,738 --> 00:34:22,190
hay alguna información útil aquí.

752
00:34:22,190 --> 00:34:24,684
>> Vamos a desplazarse hasta la parte superior.

753
00:34:24,684 --> 00:34:25,600
Aquí es donde empezamos.

754
00:34:25,600 --> 00:34:27,040
Así que no es todo lo que mucho de salida.

755
00:34:27,040 --> 00:34:30,429
Aquí hay que escribir inválida
de tamaño 4 en la línea 21.

756
00:34:30,429 --> 00:34:31,760
Bueno, ¿cuál fue la línea 21?

757
00:34:31,760 --> 00:34:34,500
Línea 21 era exactamente
esto y que tiene sentido

758
00:34:34,500 --> 00:34:37,290
que estoy en forma válida
escribir 4 bytes porque soy

759
00:34:37,290 --> 00:34:40,389
tratando de poner este entero,
que podría ser cualquier cosa,

760
00:34:40,389 --> 00:34:42,370
que sólo pasa a ser
cero, pero estoy tratando de

761
00:34:42,370 --> 00:34:44,940
para ponerlo en un lugar
que no pertenece a mí.

762
00:34:44,940 --> 00:34:50,900
Por otra parte, aquí abajo, 40 bytes en un
bloques están definitivamente perdidos en el expediente 1.

763
00:34:50,900 --> 00:34:56,500
Eso es porque cuando llamo malloc
aquí, yo en realidad nunca liberar la memoria.

764
00:34:56,500 --> 00:34:58,140
>> Entonces, ¿cómo podemos solucionar este problema?

765
00:34:58,140 --> 00:35:02,970
Déjame ir por delante y ser un poco más seguro
y hacer 9 allí y me dejó aquí gratis x.

766
00:35:02,970 --> 00:35:04,820
Esta es la nueva función para hoy.

767
00:35:04,820 --> 00:35:11,520
Si ahora me vuelva a ejecutar hacer slash dot memoria,
vamos a correr valgrind en él de nuevo,

768
00:35:11,520 --> 00:35:14,990
maximizar la ventana y pulse Enter.

769
00:35:14,990 --> 00:35:16,900
Ahora, es bueno.

770
00:35:16,900 --> 00:35:19,590
Entierran las buenas noticias
en todo esto de salida.

771
00:35:19,590 --> 00:35:20,810
Todos los bloques de montón eran libres.

772
00:35:20,810 --> 00:35:23,604
Volveremos a lo que el montón
es, pero no hay fugas son posibles.

773
00:35:23,604 --> 00:35:25,520
Así que esto es sólo otra
herramienta para su caja de herramientas

774
00:35:25,520 --> 00:35:30,220
con el que se puede empezar a
encuentra ahora los errores así.

775
00:35:30,220 --> 00:35:34,532
>> Pero vamos a ver qué
más puede salir mal aquí.

776
00:35:34,532 --> 00:35:38,890
De transición Vamos ahora a
en realidad la solución de un problema.

777
00:35:38,890 --> 00:35:42,440
Como acotación al margen, si esto va a aliviar un
poco de confusión o de tensión,

778
00:35:42,440 --> 00:35:43,430
esto es ahora divertido.

779
00:35:43,430 --> 00:35:46,400

780
00:35:46,400 --> 00:35:46,900
Sí.

781
00:35:46,900 --> 00:35:49,040
Eso es bastante bueno.

782
00:35:49,040 --> 00:35:50,890
Debido a que los punteros son
direcciones y direcciones

783
00:35:50,890 --> 00:35:53,098
generalmente son por convención
escrito con hexadecimal.

784
00:35:53,098 --> 00:35:54,650
Ja, ja, esto es gracioso ahora.

785
00:35:54,650 --> 00:35:58,390
De todos modos, así que vamos ahora
realmente resolver un problema.

786
00:35:58,390 --> 00:36:00,840
Este ha sido estupendo,
súper bajo nivel hasta el momento,

787
00:36:00,840 --> 00:36:03,950
y que en realidad podemos hacer útil
cosas con estos detalles de bajo nivel.

788
00:36:03,950 --> 00:36:06,710
>> Así que hemos introducido unas semanas
Hace la noción de una matriz.

789
00:36:06,710 --> 00:36:09,177
Un arsenal era agradable, porque
es difícil de limpiar nuestro código

790
00:36:09,177 --> 00:36:11,760
porque si queríamos escribir una
programa con múltiples estudiantes

791
00:36:11,760 --> 00:36:15,270
o múltiples nombres y casas y
residencias y colegios y todo eso,

792
00:36:15,270 --> 00:36:19,430
podríamos almacenar todo más
limpiamente dentro de una matriz.

793
00:36:19,430 --> 00:36:23,039
Pero proponer una desventaja
de una matriz hasta el momento.

794
00:36:23,039 --> 00:36:26,080
Incluso si no has sufrido tú mismo
en un programa, simplemente por instinto,

795
00:36:26,080 --> 00:36:30,870
lo que es una mala cosa
sobre una matriz, tal vez?

796
00:36:30,870 --> 00:36:32,337
Oigo algunos murmullos.

797
00:36:32,337 --> 00:36:34,170
AUDIENCIA: Es difícil
para cambiar el tamaño.

798
00:36:34,170 --> 00:36:36,128
DAVID MALAN: Es difícil
para cambiar el tamaño.

799
00:36:36,128 --> 00:36:38,660
No se puede cambiar el tamaño
de una matriz, de hecho, per se

800
00:36:38,660 --> 00:36:43,040
en C. Puede asignar otra matriz,
mover todo, desde la anterior

801
00:36:43,040 --> 00:36:45,380
en el nuevo, y ahora
tener algo más de espacio,

802
00:36:45,380 --> 00:36:47,469
pero no es como un
lenguaje como Java o Python

803
00:36:47,469 --> 00:36:49,760
o cualquier número de otra
lenguas con las que algunos de ustedes

804
00:36:49,760 --> 00:36:52,070
podría ser familiar donde
puede simplemente seguir añadiendo cosas

805
00:36:52,070 --> 00:36:53,930
hasta la saciedad hasta el final de una matriz.

806
00:36:53,930 --> 00:36:57,880
Cuando usted tiene una serie de
tamaño 6, que es su tamaño,

807
00:36:57,880 --> 00:37:01,970
y tan parecido a la idea anterior
que tiene un buffer de un cierto tamaño,

808
00:37:01,970 --> 00:37:05,940
tienes que adivinar fuera de la puerta
qué tamaño es lo que quieres que sea?

809
00:37:05,940 --> 00:37:07,880
Si adivina demasiado grande,
estás perdiendo espacio.

810
00:37:07,880 --> 00:37:10,950
Si adivina demasiado pequeño,
no puede almacenar datos que, por lo menos

811
00:37:10,950 --> 00:37:12,940
y sin mucho trabajo.

812
00:37:12,940 --> 00:37:18,180
>> Así que hoy, gracias a los punteros, podemos
comenzar uniendo nuestra propia aduana

813
00:37:18,180 --> 00:37:20,989
estructuras de datos, y en
De hecho, aquí es algo

814
00:37:20,989 --> 00:37:23,030
que se ve un poco más
críptica a primera vista,

815
00:37:23,030 --> 00:37:26,440
pero esto es lo que llamaremos una ligado
lista, y su nombre tipo de resume

816
00:37:26,440 --> 00:37:26,940
ello.

817
00:37:26,940 --> 00:37:29,550
Es una lista de números, o en
este caso, una lista de números,

818
00:37:29,550 --> 00:37:33,480
pero podría ser una lista de cualquier cosa, pero
está vinculado entre sí por medio de flechas,

819
00:37:33,480 --> 00:37:36,380
y acaba de tomar una conjetura
con qué técnica

820
00:37:36,380 --> 00:37:38,310
vamos a ser capaces de
para coser juntos,

821
00:37:38,310 --> 00:37:42,540
algo así como palomitas de maíz con un hilo,
una vinculada listas rectángulos aquí?

822
00:37:42,540 --> 00:37:43,936
Sus números?

823
00:37:43,936 --> 00:37:45,560
¿Cuál es la característica del lenguaje subyacente?

824
00:37:45,560 --> 00:37:46,350
>> AUDIENCIA: Un puntero.

825
00:37:46,350 --> 00:37:47,308
>> DAVID MALAN: Un puntero.

826
00:37:47,308 --> 00:37:51,700
Así que cada una de estas flechas representa aquí
un puntero o simplemente una dirección.

827
00:37:51,700 --> 00:37:54,590
En otras palabras, si quiero
para almacenar una lista de números,

828
00:37:54,590 --> 00:37:59,040
No puedo guardarlo si quiero
la capacidad de crecer y encoger

829
00:37:59,040 --> 00:38:00,990
mi estructura de datos en una matriz.

830
00:38:00,990 --> 00:38:03,000
Así que tengo que tener un poco de
más sofisticación,

831
00:38:03,000 --> 00:38:05,720
de notar que esta
foto tipo de sugiere

832
00:38:05,720 --> 00:38:08,650
que si usted acaba de conseguir pequeños hilos
conectar todo junto,

833
00:38:08,650 --> 00:38:13,100
probablemente no es tan difícil de hacer espacio
entre dos de los rectángulos

834
00:38:13,100 --> 00:38:16,750
o dos de esos nodos, ya que vamos a empezar
llamándolos, poner en un nuevo nodo,

835
00:38:16,750 --> 00:38:19,547
y luego con un poco de hilo nuevo, justo
deshacerse de los tres nodos juntos,

836
00:38:19,547 --> 00:38:22,880
el primero, el último, y el
que acaba de insertar en el medio.

837
00:38:22,880 --> 00:38:26,000
>> Y de hecho una lista enlazada,
a diferencia de una matriz, es dinámico.

838
00:38:26,000 --> 00:38:27,840
Puede crecer y puede
se encogen y no lo hace

839
00:38:27,840 --> 00:38:32,434
tiene que saber o cuidar de antemano cómo
cantidad de datos que van a ser el almacenamiento,

840
00:38:32,434 --> 00:38:35,600
pero resulta que tenemos que ser un poco
cuidado acerca de cómo implementar esto.

841
00:38:35,600 --> 00:38:39,070
Así que primero vamos a considerar cómo implementamos
uno de estos pequeños rectángulos.

842
00:38:39,070 --> 00:38:40,690
Es fácil de implementar un int.

843
00:38:40,690 --> 00:38:44,000
Usted acaba de decir int n y después
usted consigue 4 bytes para un int,

844
00:38:44,000 --> 00:38:49,089
pero ¿cómo puedo obtener un int, llamarlo n,
y luego un puntero, vamos a llamarlo siguiente.

845
00:38:49,089 --> 00:38:50,880
Podríamos llamar a estos
cosas lo que queramos

846
00:38:50,880 --> 00:38:53,590
pero necesito una estructura de datos personalizado.

847
00:38:53,590 --> 00:38:54,257
¿Sí?

848
00:38:54,257 --> 00:38:57,020
>> AUDIENCIA: Ampersand [inaudible].

849
00:38:57,020 --> 00:39:00,940
>> DAVID MALAN: Así signo que utilizaremos para
obtener la dirección de un nodo potencialmente.

850
00:39:00,940 --> 00:39:02,740
Pero necesitamos otro
función de C con el fin

851
00:39:02,740 --> 00:39:06,700
que me diera la posibilidad de crear
este rectángulo costumbre, esta costumbre

852
00:39:06,700 --> 00:39:08,919
variable si se quiere, en la memoria.

853
00:39:08,919 --> 00:39:09,710
AUDIENCIA: Una estructura.

854
00:39:09,710 --> 00:39:10,626
DAVID MALAN: Una estructura.

855
00:39:10,626 --> 00:39:14,310
Recordemos que la semana pasada, introdujimos
estructura, esta palabra clave relativamente simple

856
00:39:14,310 --> 00:39:16,254
que nos permite hacer cosas como esta.

857
00:39:16,254 --> 00:39:18,420
C no vino con un dato
estructura llamada estudiantil.

858
00:39:18,420 --> 00:39:22,190
Viene con int y float y carbón y
tales, pero no viene con los estudiantes,

859
00:39:22,190 --> 00:39:26,750
pero podemos crear un tipo de datos de los estudiantes,
una estructura de estudiante, con esta sintaxis

860
00:39:26,750 --> 00:39:27,250
Aquí.

861
00:39:27,250 --> 00:39:28,350
Y verás esto una y otra vez.

862
00:39:28,350 --> 00:39:30,426
Así que no te preocupes por
memorizando las palabras clave,

863
00:39:30,426 --> 00:39:33,300
pero la palabra clave que es importante es
sólo el hecho de que hemos dicho struct

864
00:39:33,300 --> 00:39:37,590
y luego lo llamamos estudiante y en el interior
del estudiante era un nombre y una casa

865
00:39:37,590 --> 00:39:39,390
o una residencia de estudiantes o similares.

866
00:39:39,390 --> 00:39:41,980
>> Y lo que ahora hoy, vamos a proponer esto.

867
00:39:41,980 --> 00:39:45,240
He añadido algunas palabras, pero si quiero
para implementar este rectángulo que es

868
00:39:45,240 --> 00:39:48,440
tiene tanto un int y un
puntero, sabes qué, yo soy

869
00:39:48,440 --> 00:39:51,540
va a declarar una estructura llamada nodo.

870
00:39:51,540 --> 00:39:55,630
Soy también, dentro de ella, va a decir
que un nodo, este rectángulo, tiene un int

871
00:39:55,630 --> 00:39:59,730
y lo vamos a llamar ny
tiene un siguiente puntero.

872
00:39:59,730 --> 00:40:02,540
Y esto es un poco prolijo,
pero si se piensa en ello,

873
00:40:02,540 --> 00:40:07,300
las flechas que se encontraban en la imagen
Hace un momento son de qué tipo de datos?

874
00:40:07,300 --> 00:40:12,330
Donde cada uno de esos flechas está apuntando
a qué tipo de estructura de datos?

875
00:40:12,330 --> 00:40:14,332
No es simplemente apuntando a un int per se.

876
00:40:14,332 --> 00:40:16,165
Se apunta a la
Lo rectangular entera

877
00:40:16,165 --> 00:40:18,720
y esa cosa rectangular,
hemos dicho, se llama un nodo.

878
00:40:18,720 --> 00:40:21,720
Y así que tipo de tener que
recursivamente definir esta tales

879
00:40:21,720 --> 00:40:26,270
que un nodo, diremos,
contendrá un int llamada n

880
00:40:26,270 --> 00:40:31,070
y un puntero llamado siguiente y el
tipo de estructura de datos a la cual

881
00:40:31,070 --> 00:40:35,770
que los puntos de puntero es aparentemente
va a ser nodo de estructura.

882
00:40:35,770 --> 00:40:41,550
>> Así que esto es molesto detallado
y acaba de ser pedante,

883
00:40:41,550 --> 00:40:44,100
la razón por la que no podemos
solo decir esto, que francamente

884
00:40:44,100 --> 00:40:46,860
parece mucho más fácil de leer,
se debe recordar que C leer

885
00:40:46,860 --> 00:40:48,710
cosas de arriba a abajo, de izquierda a derecha.

886
00:40:48,710 --> 00:40:54,120
No es hasta que tengamos el punto y coma
que en realidad existe el nodo de palabras clave.

887
00:40:54,120 --> 00:40:57,980
Así que si queremos tener este tipo de
referencia cíclica dentro de los datos

888
00:40:57,980 --> 00:41:02,120
estructura, tenemos que hacer esto, donde
decimos nodo de estructura en la parte superior, lo que

889
00:41:02,120 --> 00:41:06,770
nos da una manera de describir esto ya
cosa, entonces dentro decimos nodo de estructura,

890
00:41:06,770 --> 00:41:09,560
y luego en la última línea
decimos, todo derecho, C, por cierto,

891
00:41:09,560 --> 00:41:12,060
simplemente llame a toda esta maldita
cosa que un nodo y detener

892
00:41:12,060 --> 00:41:14,360
usando la palabra clave struct por completo.

893
00:41:14,360 --> 00:41:18,030
Así que esto es sólo una especie de una sintáctica
truco que en última instancia nos permite crear

894
00:41:18,030 --> 00:41:21,370
algo que se ve exactamente como esta.

895
00:41:21,370 --> 00:41:25,010
>> Así que si suponemos ahora que podemos
implementar esta cosa en C,

896
00:41:25,010 --> 00:41:28,040
cómo hacer que en realidad
empezar a atravesar esto?

897
00:41:28,040 --> 00:41:32,360
Bueno, de hecho, todo lo que tenemos que hacer es
repetir de izquierda a derecha y justo

898
00:41:32,360 --> 00:41:35,960
tipo de insertar nodos o eliminar nodos
o buscar cosas donde queramos,

899
00:41:35,960 --> 00:41:39,560
pero para hacer esto, vamos a seguir adelante y hacer
las cosas un poco más real porque este

900
00:41:39,560 --> 00:41:42,560
ha sido muy bajo nivel hasta el momento.

901
00:41:42,560 --> 00:41:45,700
¿A alguien le gusta, literalmente, ser el primero?

902
00:41:45,700 --> 00:41:46,200
OK.

903
00:41:46,200 --> 00:41:47,092
Vamos arriba.

904
00:41:47,092 --> 00:41:47,800
¿Cómo te llamas?

905
00:41:47,800 --> 00:41:48,499
>> DAVID: David.

906
00:41:48,499 --> 00:41:49,290
DAVID MALAN: David.

907
00:41:49,290 --> 00:41:49,998
Encantada de conocerte.

908
00:41:49,998 --> 00:41:50,960
Yo también.

909
00:41:50,960 --> 00:41:52,450
Correcto.

910
00:41:52,450 --> 00:41:53,990
Y necesitamos un número 9.

911
00:41:53,990 --> 00:41:55,240
No es tan buena como la primera, tal vez.

912
00:41:55,240 --> 00:41:56,430
OK, número 9.

913
00:41:56,430 --> 00:41:59,667
Un número 17, por favor.

914
00:41:59,667 --> 00:42:01,000
Permítanme volver un poco más lejos.

915
00:42:01,000 --> 00:42:03,980
Número 22, por favor, y
¿qué hay de más atrás

916
00:42:03,980 --> 00:42:06,344
si puedo ver ninguna mano
con toda la luz o no.

917
00:42:06,344 --> 00:42:08,010
Alguien se ofreció allí mismo.

918
00:42:08,010 --> 00:42:08,968
¿Quieres venir?

919
00:42:08,968 --> 00:42:10,450
Su antebrazo va por la fuerza hacia arriba.

920
00:42:10,450 --> 00:42:12,340
OK, 17.

921
00:42:12,340 --> 00:42:13,690
22.

922
00:42:13,690 --> 00:42:15,120
26 se viene abajo.

923
00:42:15,120 --> 00:42:18,450
¿A alguien más que quiera
forcefully-- Vamos para arriba.

924
00:42:18,450 --> 00:42:21,030
Un voluntario real.

925
00:42:21,030 --> 00:42:23,330
>> Así que muy rápidamente, si
ustedes podrían arreglar

926
00:42:23,330 --> 00:42:26,550
Al igual que ustedes mismos
los nodos en la pantalla.

927
00:42:26,550 --> 00:42:27,510
Gracias.

928
00:42:27,510 --> 00:42:29,234
Y podrás 26.

929
00:42:29,234 --> 00:42:30,650
Todas las presentaciones adecuadas y rápidas.

930
00:42:30,650 --> 00:42:32,139
Así que soy David y tú también?

931
00:42:32,139 --> 00:42:32,680
DAVID: David.

932
00:42:32,680 --> 00:42:33,721
DAVID MALAN: ¿Y usted es?

933
00:42:33,721 --> 00:42:34,229
JAKE: Jake.

934
00:42:34,229 --> 00:42:34,729
SUE: Sue.

935
00:42:34,729 --> 00:42:35,229
ALEX: Alex.

936
00:42:35,229 --> 00:42:36,475
RAPHAEL: Raphael.

937
00:42:36,475 --> 00:42:37,100
TAYLOR: Taylor.

938
00:42:37,100 --> 00:42:37,466
DAVID MALAN: Taylor.

939
00:42:37,466 --> 00:42:37,590
Excelente.

940
00:42:37,590 --> 00:42:39,810
Así que estos son nuestros voluntarios
para hoy y seguir adelante

941
00:42:39,810 --> 00:42:43,090
y cambiar un poco de esa manera,
y sólo seguir adelante y mantener

942
00:42:43,090 --> 00:42:47,024
la celebración de sus números como usted o su
primer signo y el uso de la mano izquierda,

943
00:42:47,024 --> 00:42:48,940
seguir adelante y simplemente aplicar
estas flechas, simplemente

944
00:42:48,940 --> 00:42:51,360
de modo que la mano izquierda es, literalmente,
apuntando a lo que sea, tiene que introducir

945
00:42:51,360 --> 00:42:54,610
a, y darle un poco de espacio para que
podemos ver visualmente los brazos realidad

946
00:42:54,610 --> 00:42:58,120
apuntando, y sólo puede apuntar
tipo de en la planta está muy bien.

947
00:42:58,120 --> 00:43:03,040
>> Así que aquí tenemos una lista enlazada de uno,
dos, tres, cuatro, cinco nodos inicialmente,

948
00:43:03,040 --> 00:43:05,860
y note que tenemos este especial
puntero al principio quién es

949
00:43:05,860 --> 00:43:09,770
clave porque tenemos que seguir la pista
de la lista de longitud entera de alguna manera.

950
00:43:09,770 --> 00:43:13,590
Estos chicos, a pesar de que uno se queda
a derecha, espalda con espalda en la memoria,

951
00:43:13,590 --> 00:43:15,950
que en realidad puede estar en cualquier lugar
en la memoria del ordenador.

952
00:43:15,950 --> 00:43:18,240
Así que estos chicos podrían ser
de pie en cualquier lugar en el escenario

953
00:43:18,240 --> 00:43:20,960
y eso está bien, siempre y cuando estén
realmente apuntando el uno al otro,

954
00:43:20,960 --> 00:43:22,770
pero para mantener las cosas
limpio y sencillo, vamos a

955
00:43:22,770 --> 00:43:25,728
simplemente dibujarlas de izquierda a derecha como
esto, pero podría haber brechas masivas

956
00:43:25,728 --> 00:43:26,790
entre esos nodos.

957
00:43:26,790 --> 00:43:30,710
>> Ahora, si quiero insertar en realidad algunos
nuevo valor, vamos a seguir adelante y hacer esto.

958
00:43:30,710 --> 00:43:33,720
Tenemos una oportunidad ahora
elegir otro nodo.

959
00:43:33,720 --> 00:43:39,820
Decir que vamos a empezar con mallocing 55.

960
00:43:39,820 --> 00:43:41,320
¿Alguien importaría ser malloc?

961
00:43:41,320 --> 00:43:42,280
OK, vamos para arriba.

962
00:43:42,280 --> 00:43:42,992
¿Cómo te llamas?

963
00:43:42,992 --> 00:43:43,700
ARCO IRIS: Arco iris.

964
00:43:43,700 --> 00:43:44,050
DAVID MALAN: Arco iris?

965
00:43:44,050 --> 00:43:44,810
Correcto.

966
00:43:44,810 --> 00:43:46,600
Rainbow Malloc.

967
00:43:46,600 --> 00:43:47,450
Vamos arriba.

968
00:43:47,450 --> 00:43:51,610
Así que ahora tenemos que preguntarnos a nosotros mismos
algorítmicamente donde podemos poner 55.

969
00:43:51,610 --> 00:43:53,610
Así que todos sabemos,
Obviamente, en la que, probablemente,

970
00:43:53,610 --> 00:43:55,401
pertenece, si estamos tratando
para mantener este ordenadas

971
00:43:55,401 --> 00:43:58,299
y si ustedes podrían tomar uno
un paso atrás para que no se caigan

972
00:43:58,299 --> 00:43:59,590
el escenario, que sería genial.

973
00:43:59,590 --> 00:44:01,420
Así que en realidad, arco iris,
empezar de nuevo aquí conmigo,

974
00:44:01,420 --> 00:44:04,200
porque como el equipo ahora puede
sólo ven una variable a la vez.

975
00:44:04,200 --> 00:44:05,190
Así que si este es el primer nodo.

976
00:44:05,190 --> 00:44:07,160
Observe que no es un nodo,
él es sólo un indicador,

977
00:44:07,160 --> 00:44:10,270
y es por eso que ha dibujado para ser
sólo el tamaño de un puntero, no

978
00:44:10,270 --> 00:44:11,780
uno de esos rectángulos completos.

979
00:44:11,780 --> 00:44:16,650
Así que vamos a comprobar en cada
iteración es 55 menos de 9?

980
00:44:16,650 --> 00:44:17,150
No.

981
00:44:17,150 --> 00:44:19,060
Es 55 de menos de 17?

982
00:44:19,060 --> 00:44:19,720
No.

983
00:44:19,720 --> 00:44:20,800
Menos de 22?

984
00:44:20,800 --> 00:44:22,020
Menos de 26?

985
00:44:22,020 --> 00:44:23,390
Menos de 34?

986
00:44:23,390 --> 00:44:25,890
Y así es, obviamente,
Rainbow pertenece al final.

987
00:44:25,890 --> 00:44:27,270
Así que para ser claros, y qué
era su nombre, Taylor?

988
00:44:27,270 --> 00:44:27,895
>> TAYLOR: Taylor.

989
00:44:27,895 --> 00:44:32,510
DAVID MALAN: Así que entre Taylor
mano izquierda y las manos del arco iris aquí,

990
00:44:32,510 --> 00:44:38,324
cuya mano debe apuntar a lo que en
Para insertar 55 en esta lista?

991
00:44:38,324 --> 00:44:39,240
¿Qué necesitamos hacer?

992
00:44:39,240 --> 00:44:39,700
¿Sí?

993
00:44:39,700 --> 00:44:41,140
>> AUDIENCIA: la mano de Taylor
hay que señalar izquierda.

994
00:44:41,140 --> 00:44:41,680
>> DAVID MALAN: Exactamente.

995
00:44:41,680 --> 00:44:43,800
Así la inserción de un nodo
en el final de la lista

996
00:44:43,800 --> 00:44:47,140
es bastante simple porque Taylor acaba
tiene que señalar, en lugar de en el suelo

997
00:44:47,140 --> 00:44:49,640
o lo llamaremos nulo,
nula es una especie de ausencia

998
00:44:49,640 --> 00:44:51,640
de un puntero o una especial
puntero cero, eres

999
00:44:51,640 --> 00:44:53,740
va a señalar con su izquierda
la mano en el Rainbow y luego del arco iris,

1000
00:44:53,740 --> 00:44:55,910
donde debe su izquierda
Probablemente mano punto?

1001
00:44:55,910 --> 00:44:56,570
Abajo.

1002
00:44:56,570 --> 00:45:00,140
No es bueno si la mano es una especie
de señalar fuera de aquí o de cualquier tipo

1003
00:45:00,140 --> 00:45:00,640
en qué dirección.

1004
00:45:00,640 --> 00:45:02,407
Eso sería considerado
un valor de basura,

1005
00:45:02,407 --> 00:45:04,240
pero si ella apunta a
algún valor conocido, vamos a

1006
00:45:04,240 --> 00:45:07,360
llamar cero o nula, eso está bien
porque tenemos un término en este

1007
00:45:07,360 --> 00:45:09,390
y sabemos que la lista ya está completo.

1008
00:45:09,390 --> 00:45:11,550
>> Entonces, ¿qué otra
caso relativamente simple?

1009
00:45:11,550 --> 00:45:13,125
¿Podríamos malloc 5?

1010
00:45:13,125 --> 00:45:14,010
Vamos arriba.

1011
00:45:14,010 --> 00:45:14,782
¿Cómo te llamas?

1012
00:45:14,782 --> 00:45:15,490
TIFFANY: Tiffany.

1013
00:45:15,490 --> 00:45:16,000
DAVID MALAN: Lo siento?

1014
00:45:16,000 --> 00:45:16,470
TIFFANY: Tiffany.

1015
00:45:16,470 --> 00:45:16,880
DAVID MALAN: Tiffany.

1016
00:45:16,880 --> 00:45:17,110
Correcto.

1017
00:45:17,110 --> 00:45:19,071
Tiffany ha sido malloced
con el valor 5.

1018
00:45:19,071 --> 00:45:19,570
Vamos arriba.

1019
00:45:19,570 --> 00:45:23,820
Éste es relativamente fácil también, pero
vamos a considerar el orden de operaciones ahora.

1020
00:45:23,820 --> 00:45:25,820
Era bastante fácil
con Taylor en el extremo.

1021
00:45:25,820 --> 00:45:30,302
Número 5 es, por supuesto, menos de 9,
y por eso tenemos a David, tenemos Tiffany,

1022
00:45:30,302 --> 00:45:31,260
y cuál era su nombre?

1023
00:45:31,260 --> 00:45:31,680
>> JAKE: Jake.

1024
00:45:31,680 --> 00:45:32,470
>> DAVID MALAN: Jake.

1025
00:45:32,470 --> 00:45:34,300
Tiffany, Jake, y David.

1026
00:45:34,300 --> 00:45:36,580
Cuya mano debe actualizarse primero?

1027
00:45:36,580 --> 00:45:39,260

1028
00:45:39,260 --> 00:45:40,590
¿Qué quieres hacer aquí?

1029
00:45:40,590 --> 00:45:45,244
Hay posibles formas en que un par, pero
también hay una o más formas equivocadas.

1030
00:45:45,244 --> 00:45:46,620
>> AUDIENCIA: Comience con el extremo izquierdo.

1031
00:45:46,620 --> 00:45:47,800
>> DAVID MALAN: Comience con el extremo izquierdo.

1032
00:45:47,800 --> 00:45:49,008
¿Quién es el más a la izquierda aquí, entonces?

1033
00:45:49,008 --> 00:45:49,700
AUDIENCIA: Primero.

1034
00:45:49,700 --> 00:45:50,366
>> DAVID MALAN: OK.

1035
00:45:50,366 --> 00:45:53,781
Así que empieza con la primera y donde hacer
desee actualizar las manos de David para ser?

1036
00:45:53,781 --> 00:45:54,780
AUDIENCIA: Hacia el 5.

1037
00:45:54,780 --> 00:45:55,446
DAVID MALAN: OK.

1038
00:45:55,446 --> 00:45:59,026
Así que David, a las cinco en punto
o Tiffany aquí y ahora?

1039
00:45:59,026 --> 00:46:01,072
>> AUDIENCIA: Tiffany apunta al 9?

1040
00:46:01,072 --> 00:46:04,030
DAVID MALAN: Perfecto, excepto Binky de
cabeza sólo un poco se cayó, ¿verdad?

1041
00:46:04,030 --> 00:46:06,820
Porque lo que tiene de malo
esta imagen literalmente?

1042
00:46:06,820 --> 00:46:08,070
AUDIENCIA: Nada está apuntando.

1043
00:46:08,070 --> 00:46:09,945
DAVID MALAN: Nada es
señalando a Jake ahora.

1044
00:46:09,945 --> 00:46:13,360
Literalmente Hemos huérfanos 9
y 17, y hemos literalmente

1045
00:46:13,360 --> 00:46:18,450
filtrado toda esta memoria, porque por
actualización de la mano de David primero, eso es

1046
00:46:18,450 --> 00:46:21,660
bien en la medida en que es correcta
señalando en Tiffany ahora,

1047
00:46:21,660 --> 00:46:25,410
pero si nadie tuvo la
previsión para apuntar a Jake,

1048
00:46:25,410 --> 00:46:27,490
entonces hemos perdido la
totalidad de esa lista.

1049
00:46:27,490 --> 00:46:28,200
Así que vamos a deshacer.

1050
00:46:28,200 --> 00:46:30,950
Así que fue una buena cosa para
tropezar pero vamos a corregir ahora.

1051
00:46:30,950 --> 00:46:33,624
¿Qué debemos hacer primero su lugar?

1052
00:46:33,624 --> 00:46:34,124
¿Sí?

1053
00:46:34,124 --> 00:46:35,791
>> AUDIENCIA: Tiffany debe apuntar al 9?

1054
00:46:35,791 --> 00:46:37,582
DAVID MALAN: No puedo
conseguir que cerca de usted.

1055
00:46:37,582 --> 00:46:38,720
¿Quién debe apuntar al 9?

1056
00:46:38,720 --> 00:46:39,220
>> AUDIENCIA: Tiffany.

1057
00:46:39,220 --> 00:46:39,390
>> DAVID MALAN: De acuerdo.

1058
00:46:39,390 --> 00:46:41,200
Así Tiffany deberían primer punto en el 9.

1059
00:46:41,200 --> 00:46:43,550
Así Tiffany debe tomar
en un valor idéntico

1060
00:46:43,550 --> 00:46:45,820
a David, lo que parece
redundante por un momento,

1061
00:46:45,820 --> 00:46:48,820
pero eso está bien, porque ahora, segundo
paso, podemos actualizar la mano de David

1062
00:46:48,820 --> 00:46:52,680
señalar con diamantes, y luego, si
nosotros, sólo un poco de limpiar las cosas

1063
00:46:52,680 --> 00:46:55,740
como si esto es una especie de primaveral,
ahora que es una inserción correcta.

1064
00:46:55,740 --> 00:46:56,700
Así excelente.

1065
00:46:56,700 --> 00:46:57,970
Así que ahora ya casi estamos allí.

1066
00:46:57,970 --> 00:47:01,075
Vamos a insertar un último
valor como el valor 20.

1067
00:47:01,075 --> 00:47:03,010
Si pudiéramos malloc un voluntario final?

1068
00:47:03,010 --> 00:47:04,140
Vamos arriba.

1069
00:47:04,140 --> 00:47:06,224
Así que éste es un poco más complicado.

1070
00:47:06,224 --> 00:47:08,390
Pero en realidad, el código somos
escribir, aunque verbalmente,

1071
00:47:08,390 --> 00:47:10,610
es como tener un montón
si las condiciones de ahora, ¿verdad?

1072
00:47:10,610 --> 00:47:12,318
Tuvimos una condición
comprobar si pertenece

1073
00:47:12,318 --> 00:47:13,840
al final, tal vez el principio.

1074
00:47:13,840 --> 00:47:15,940
Necesitamos algún tipo de lazo para
encontrar el punto en el centro.

1075
00:47:15,940 --> 00:47:17,400
Así que vamos a hacer eso con lo que es su nombre?

1076
00:47:17,400 --> 00:47:17,700
>> ERIC: Eric.

1077
00:47:17,700 --> 00:47:18,340
>> DAVID MALAN: Eric?

1078
00:47:18,340 --> 00:47:18,660
Eric.

1079
00:47:18,660 --> 00:47:19,368
Encantada de conocerte.

1080
00:47:19,368 --> 00:47:20,490
Así que tenemos 20.

1081
00:47:20,490 --> 00:47:21,220
Menos de cinco?

1082
00:47:21,220 --> 00:47:21,530
No.

1083
00:47:21,530 --> 00:47:22,160
Menos de nueve?

1084
00:47:22,160 --> 00:47:22,410
No.

1085
00:47:22,410 --> 00:47:23,050
Menos de 17?

1086
00:47:23,050 --> 00:47:23,550
No.

1087
00:47:23,550 --> 00:47:23,740
OK.

1088
00:47:23,740 --> 00:47:25,701
Él pertenece aquí y
sus nombres son de nuevo?

1089
00:47:25,701 --> 00:47:26,200
SUE: Sue.

1090
00:47:26,200 --> 00:47:26,880
DAVID MALAN: Sue.

1091
00:47:26,880 --> 00:47:27,379
ALEX: Alex.

1092
00:47:27,379 --> 00:47:28,790
DAVID MALAN: Sue, Alex, y?

1093
00:47:28,790 --> 00:47:29,290
ERIC: Eric.

1094
00:47:29,290 --> 00:47:30,120
DAVID MALAN: Eric.

1095
00:47:30,120 --> 00:47:32,140
Cuyas manos tienen que actualizarse primero?

1096
00:47:32,140 --> 00:47:32,930
>> AUDIENCIA: Eric.

1097
00:47:32,930 --> 00:47:33,429
OK.

1098
00:47:33,429 --> 00:47:35,200
Así que Eric debería apuntar a dónde?

1099
00:47:35,200 --> 00:47:35,930
A los 22 años.

1100
00:47:35,930 --> 00:47:36,430
Bien.

1101
00:47:36,430 --> 00:47:38,180
Y ahora ¿qué sigue?

1102
00:47:38,180 --> 00:47:40,800
Sue entonces puede apuntar a Eric
y ahora, si ustedes solo

1103
00:47:40,800 --> 00:47:44,077
hacer un poco de espacio, lo cual está bien
visualmente, ahora que hemos hecho de la inserción.

1104
00:47:44,077 --> 00:47:47,160
Así que vamos a considerar ahora una pregunta, pero
muchas gracias a nuestros voluntarios.

1105
00:47:47,160 --> 00:47:48,090
Muy bien hecho.

1106
00:47:48,090 --> 00:47:50,831
Usted puede mantener esos, si lo desea.

1107
00:47:50,831 --> 00:47:54,140
Y tenemos un regalo de despedida encantador si
que le gusta cada uno para tomar una pelota anti-estrés.

1108
00:47:54,140 --> 00:47:56,030
Permítanme pasar esto.

1109
00:47:56,030 --> 00:47:58,430
Entonces, ¿qué es la comida para llevar de todo esto?

1110
00:47:58,430 --> 00:48:02,430
Esto parece ser increíble
en la medida en que tenemos ahora

1111
00:48:02,430 --> 00:48:06,360
introducido una alternativa a una
matriz que no está tan limitado

1112
00:48:06,360 --> 00:48:07,780
a una matriz de un cierto tamaño fijo.

1113
00:48:07,780 --> 00:48:09,380
Pueden crecer dinámicamente.

1114
00:48:09,380 --> 00:48:13,220
>> Pero al igual que hemos visto en semanas
pasado, que nunca consiguió nada de forma gratuita,

1115
00:48:13,220 --> 00:48:15,740
como seguramente hay un trade-off aquí.

1116
00:48:15,740 --> 00:48:18,890
Así, con un alza de un ligado
lista, es este dinamismo?

1117
00:48:18,890 --> 00:48:21,590
Esta capacidad de crecer y, francamente,
podríamos haber hecho de eliminación

1118
00:48:21,590 --> 00:48:23,570
y podríamos reducir, según sea necesario.

1119
00:48:23,570 --> 00:48:24,710
¿Qué precio estamos pagando?

1120
00:48:24,710 --> 00:48:28,510

1121
00:48:28,510 --> 00:48:30,340
El doble de espacio, en primer lugar.

1122
00:48:30,340 --> 00:48:34,010
Si nos fijamos en la imagen, ya no
estoy almacenando una lista de enteros.

1123
00:48:34,010 --> 00:48:36,740
Estoy almacenar una lista de
enteros más punteros.

1124
00:48:36,740 --> 00:48:38,240
Así que estoy duplicando la cantidad de espacio.

1125
00:48:38,240 --> 00:48:40,740
Ahora, tal vez eso no es tal
una gran cosa 4 bytes, 8 bytes,

1126
00:48:40,740 --> 00:48:43,160
pero sin duda podría añadir
para grandes conjuntos de datos.

1127
00:48:43,160 --> 00:48:45,570
¿Cuál es otra desventaja?

1128
00:48:45,570 --> 00:48:46,070
¿Sí?

1129
00:48:46,070 --> 00:48:48,010
>> AUDIENCIA: Tenemos que
atravesar ellos uno por uno.

1130
00:48:48,010 --> 00:48:48,760
DAVID MALAN: Sí.

1131
00:48:48,760 --> 00:48:50,260
Tenemos que atravesar ellos uno por uno.

1132
00:48:50,260 --> 00:48:53,860
¿Sabes qué, nos dimos por vencidos esta super
práctica función de corchetes

1133
00:48:53,860 --> 00:48:57,240
notación, más propiamente
conocida como acceso aleatorio,

1134
00:48:57,240 --> 00:48:59,280
en el que sólo podemos saltar
a un elemento individual

1135
00:48:59,280 --> 00:49:01,470
pero ahora si todavía tenía
mis voluntarios aquí,

1136
00:49:01,470 --> 00:49:04,660
si quería encontrar la
número 22, no puedo simplemente

1137
00:49:04,660 --> 00:49:06,620
saltar al soporte de algo de algo.

1138
00:49:06,620 --> 00:49:10,530
Tengo que mirar por encima de la lista, y mucho
como nuestros ejemplos de búsqueda de forma lineal,

1139
00:49:10,530 --> 00:49:12,260
para encontrar el número 22.

1140
00:49:12,260 --> 00:49:14,340
Así que parece que hemos pagado un precio allí.

1141
00:49:14,340 --> 00:49:16,430
Pero podemos, sin embargo,
resolver otros problemas.

1142
00:49:16,430 --> 00:49:18,587
>> De hecho, permítanme presentarles
sólo un par de imágenes.

1143
00:49:18,587 --> 00:49:20,920
Así que si usted ha sido hasta
De Mather Dining Hall recientemente,

1144
00:49:20,920 --> 00:49:23,320
usted recordará que su
pilas de bandejas de este tipo,

1145
00:49:23,320 --> 00:49:26,300
pedimos prestado estos de
Annenberg antes de la clase.

1146
00:49:26,300 --> 00:49:28,930
Así que esta pila de bandejas, sin embargo,
es representativa realidad

1147
00:49:28,930 --> 00:49:30,860
de una estructura de datos informática.

1148
00:49:30,860 --> 00:49:32,910
Hay una estructura de datos
en ciencias de la computación

1149
00:49:32,910 --> 00:49:38,010
conocido como una pila que muy bien
se presta a exactamente esto visual.

1150
00:49:38,010 --> 00:49:41,380
Así que si cada una de estas bandejas no es una
Bandeja pero al igual que un número y que quería

1151
00:49:41,380 --> 00:49:45,010
para almacenar números,
podría poner un hasta aquí,

1152
00:49:45,010 --> 00:49:48,320
y pude poner otro aquí abajo,
y continuar apilamiento números

1153
00:49:48,320 --> 00:49:53,180
en la parte superior uno de otro, y lo que es
potencialmente útil sobre este

1154
00:49:53,180 --> 00:49:55,450
es que lo que es la implicación
de esta estructura de datos?

1155
00:49:55,450 --> 00:49:58,045
¿Qué número puedo sacar
primero más conveniente?

1156
00:49:58,045 --> 00:50:00,640

1157
00:50:00,640 --> 00:50:03,030
El más reciente se metió allí.

1158
00:50:03,030 --> 00:50:06,430
>> Así que esto es lo que llamaríamos en
ciencias de la computación una estructura de datos LIFO.

1159
00:50:06,430 --> 00:50:08,070
Último en entrar primero en salir.

1160
00:50:08,070 --> 00:50:10,800
Y veremos en poco tiempo por qué
que podría ser útil, pero por ahora,

1161
00:50:10,800 --> 00:50:12,200
basta con considerar la propiedad.

1162
00:50:12,200 --> 00:50:15,158
Y es un poco estúpido si usted piensa
acerca de cómo el comedor hace.

1163
00:50:15,158 --> 00:50:17,910
Cada vez que las bandejas limpias y
poner los más frescos en la parte superior,

1164
00:50:17,910 --> 00:50:22,160
usted podría tener una previamente limpia
pero con el tiempo muy sucio y polvoriento

1165
00:50:22,160 --> 00:50:24,360
la bandeja en la parte inferior
si en realidad nunca

1166
00:50:24,360 --> 00:50:26,820
llegar al fondo de esa
pila, ya que acaba de

1167
00:50:26,820 --> 00:50:29,380
seguir poniendo el nuevo y
los limpios en la parte superior de la misma.

1168
00:50:29,380 --> 00:50:31,840
Lo mismo podría suceder
en un supermercado también.

1169
00:50:31,840 --> 00:50:35,450
Si usted tiene una vitrina
de leche y cada vez CVS

1170
00:50:35,450 --> 00:50:37,610
o quien obtiene más leche,
que acaba empuja las leches

1171
00:50:37,610 --> 00:50:39,880
ya tiene a la espalda y
poner los nuevos en la delantera,

1172
00:50:39,880 --> 00:50:43,088
usted va a tener algunos bastante desagradable
leche en el extremo de la estructura de datos,

1173
00:50:43,088 --> 00:50:46,390
porque siempre en la parte inferior o
equivalentemente siempre en la parte posterior.

1174
00:50:46,390 --> 00:50:50,407
>> Pero hay otra manera de pensar
alineando los datos y, por ejemplo, esta.

1175
00:50:50,407 --> 00:50:53,490
Si eres una de esas personas que le gusta
para alinear las afueras de las tiendas de Apple

1176
00:50:53,490 --> 00:50:55,610
cuando llega un nuevo producto
a cabo, es probable que

1177
00:50:55,610 --> 00:50:58,780
no se utiliza un datos de la pila
estructura porque

1178
00:50:58,780 --> 00:51:03,070
alejaría a todos los demás que es
haciendo cola para comprar un nuevo juguete.

1179
00:51:03,070 --> 00:51:06,610
Más bien, es probable que estés usando
qué tipo de estructura de datos

1180
00:51:06,610 --> 00:51:10,050
o qué tipo de sistema
¿en el mundo real?

1181
00:51:10,050 --> 00:51:13,493
Esperemos que sea una línea, o más
adecuadamente o más británico-como, una cola.

1182
00:51:13,493 --> 00:51:17,700
Y resulta que una cola es también un
estructura de datos en ciencias de la computación,

1183
00:51:17,700 --> 00:51:19,700
pero una cola tiene un muy
distinta propiedad.

1184
00:51:19,700 --> 00:51:20,820
No es LIFO.

1185
00:51:20,820 --> 00:51:21,990
Último en entrar primero en salir.

1186
00:51:21,990 --> 00:51:22,800
Dios no lo quiera.

1187
00:51:22,800 --> 00:51:24,280
Es lugar FIFO.

1188
00:51:24,280 --> 00:51:26,110
Primero en entrar primero en salir.

1189
00:51:26,110 --> 00:51:27,970
Y eso es una buena cosa
por causa de la justicia

1190
00:51:27,970 --> 00:51:30,428
sin duda cuando se está alineando
hasta muy temprano en la mañana.

1191
00:51:30,428 --> 00:51:33,400
Si llegas primero,
querer salir primero también.

1192
00:51:33,400 --> 00:51:35,880
>> Y así, todos estos datos
estructuras, colas y pilas

1193
00:51:35,880 --> 00:51:39,220
y racimos de otros, resulta que
puede pensar en esto como una matriz.

1194
00:51:39,220 --> 00:51:41,820
Esta es una matriz, tal vez
un tamaño fijo 4, pero sería

1195
00:51:41,820 --> 00:51:44,990
ser algo bueno si pudiéramos acumular
bandejas casi infinitamente alto si

1196
00:51:44,990 --> 00:51:46,780
tener esa cantidad de bandejas o números.

1197
00:51:46,780 --> 00:51:48,840
Así que tal vez queremos
utilizar una lista enlazada aquí,

1198
00:51:48,840 --> 00:51:51,800
pero la compensación va a ser
potencialmente que necesitamos más memoria,

1199
00:51:51,800 --> 00:51:55,930
toma un poco más de tiempo, pero nosotros
no limitar la altura de la pila,

1200
00:51:55,930 --> 00:51:59,550
mucho como vitrina de Mather
podría limitar el tamaño de la pila,

1201
00:51:59,550 --> 00:52:03,117
y así se trata de decisiones de diseño o
opciones disponibles para nosotros en última instancia.

1202
00:52:03,117 --> 00:52:04,950
Así, con estos datos
estructuras, que han empezado

1203
00:52:04,950 --> 00:52:09,360
ver nuevos límites superiores potencialmente
en lo que antes era súper rápido

1204
00:52:09,360 --> 00:52:11,260
y donde dejaremos
de hoy y donde

1205
00:52:11,260 --> 00:52:13,200
vamos Esperamos llegar
es el miércoles, vamos a

1206
00:52:13,200 --> 00:52:15,740
empezar a mirar un dato
estructura que nos permite buscamos

1207
00:52:15,740 --> 00:52:18,260
a través de los datos en tiempo final de registro de nuevo.

1208
00:52:18,260 --> 00:52:21,470
Y vimos que, recordemos, en la semana cero
y otro con búsqueda binaria o dividir

1209
00:52:21,470 --> 00:52:22,180
y conquistar.

1210
00:52:22,180 --> 00:52:26,240
Se va a volver y mejor aún,
el santo grial para este miércoles

1211
00:52:26,240 --> 00:52:29,510
será la de llegar a la
estructura de datos que se ejecuta realmente

1212
00:52:29,510 --> 00:52:32,070
o teóricamente en
constante de tiempo, con lo cual

1213
00:52:32,070 --> 00:52:34,760
no importa cuántos
millones o miles de millones de cosas

1214
00:52:34,760 --> 00:52:38,470
que tenemos en la estructura de datos, lo hará
llevarnos constante de tiempo, tal vez un paso

1215
00:52:38,470 --> 00:52:41,387
o dos pasos o 10 pasos,
pero los números constantes de pasos

1216
00:52:41,387 --> 00:52:42,970
para buscar a través de esa estructura de datos.

1217
00:52:42,970 --> 00:52:46,300
Ese hecho será el santo grial
pero más en que el miércoles.

1218
00:52:46,300 --> 00:52:49,045
Nos vemos entonces.

1219
00:52:49,045 --> 00:52:53,704
>> [REPRODUCCIÓN DE MÚSICA]

1220
00:52:53,704 --> 00:56:08,448