1
00:00:00,000 --> 00:00:02,310
[Powered by Google Translate] [Semana 4, continuación]

2
00:00:02,310 --> 00:00:04,240
[David J. Malan - Harvard University]

3
00:00:04,240 --> 00:00:07,290
[Esta es CS50. - CS50.TV]

4
00:00:07,290 --> 00:00:11,290
>> Esto es CS50, y este es el fin de semana 4.

5
00:00:11,290 --> 00:00:14,030
Así que una buena noticia y una mala noticia.

6
00:00:14,030 --> 00:00:26,240
No conferencia el lunes, no hay problema fijado la próxima semana. [Estudiantes vitoreando]

7
00:00:26,240 --> 00:00:28,680
No te va a gustar a dónde va esto.

8
00:00:28,680 --> 00:00:31,590
Pero tenemos este lugar el próximo miércoles,

9
00:00:31,590 --> 00:00:37,740
y también hay un programa de estudios por la conferencia el próximo viernes viernes para que podamos mantener el rumbo.

10
00:00:37,740 --> 00:00:40,580
Pero todo va a ser filmado, como de costumbre, por lo que no se preocupara.

11
00:00:40,580 --> 00:00:44,100
>> Y con respecto a quiz 0 lo que vamos a hacer a finales de la semana

12
00:00:44,100 --> 00:00:47,140
se publique en cs50.net página de inicio del curso una explicación

13
00:00:47,140 --> 00:00:50,160
de qué tipo de expectativas que usted debe tener cuando se trata de la primera prueba.

14
00:00:50,160 --> 00:00:55,100
En general, será de opción múltiple, verdadero-falso, respuesta corta, corta los problemas de codificación.

15
00:00:55,100 --> 00:00:57,360
Usted no va a esperar para poner en práctica el equivalente

16
00:00:57,360 --> 00:01:00,030
de un problema que usted vería en un conjunto de procesadores, para lo cual dispone de un ordenador

17
00:01:00,030 --> 00:01:03,240
y un depurador y similares, pero habrá pequeños problemas de codificación.

18
00:01:03,240 --> 00:01:06,900
>> Y, en efecto, la mejor guía para tener una idea de lo que CS50 concursos son como

19
00:01:06,900 --> 00:01:09,180
es ir a cs50.net, vaya al enlace de Concursos,

20
00:01:09,180 --> 00:01:11,920
y se puede ver en los últimos años por valor de concursos.

21
00:01:11,920 --> 00:01:16,600
Sólo se dan cuenta de que el plan de estudios no siempre ha sido igual a lo largo de los años.

22
00:01:16,600 --> 00:01:18,510
A veces se añade, a veces, restar,

23
00:01:18,510 --> 00:01:20,670
así que si ves algún tema en uno de esos viejos concursos

24
00:01:20,670 --> 00:01:25,380
que usted no tiene idea de lo que está hablando, o es que lo cubra

25
00:01:25,380 --> 00:01:27,210
o que no lo cubra.

26
00:01:27,210 --> 00:01:31,110
Pero en la forma de opiniones, este domingo, lunes y martes

27
00:01:31,110 --> 00:01:34,770
así como un curso de toda la sesión de revisión en la noche del domingo -

28
00:01:34,770 --> 00:01:37,500
hora y lugar que se anunciará en la página principal del curso -

29
00:01:37,500 --> 00:01:40,120
que todos tengan la oportunidad de revisar con compañeros docentes del curso

30
00:01:40,120 --> 00:01:44,830
el material para este año, tanto en la sección y como una clase completa,

31
00:01:44,830 --> 00:01:48,400
y los que se filmará como siempre también.

32
00:01:48,400 --> 00:01:53,380
>> Está bien. Así que sin más preámbulos, un comentario sobre pasa / no pasa y add / drop.

33
00:01:53,380 --> 00:01:57,980
Es posible que haya visto mis notas anoche, y esto es sólo un poco de tranquilidad adicional

34
00:01:57,980 --> 00:02:01,250
que si usted está entre los menos cómodos en particular o en algún punto intermedio

35
00:02:01,250 --> 00:02:04,870
y te sientes un poco adentro sobre su cabeza,

36
00:02:04,870 --> 00:02:08,430
darse cuenta de que es de hecho bastante normal, y no hay una estructura de apoyo suficiente en el lugar,

37
00:02:08,430 --> 00:02:13,530
uno de los cuales las horas de oficina tenían la intención de mejorar aún más por la última noche de correo electrónico,

38
00:02:13,530 --> 00:02:16,520
y darse cuenta también que una opción como apto / no apto para una clase como esta

39
00:02:16,520 --> 00:02:21,540
realmente se entiende como un mecanismo para tomar el borde de un curso como éste,

40
00:02:21,540 --> 00:02:24,200
de modo que de nuevo si usted está gastando esos 10, 15, 20 horas

41
00:02:24,200 --> 00:02:28,160
tratando de obtener algún conjunto de procesadores para trabajar y usted sabe que usted es el 90-95% del camino

42
00:02:28,160 --> 00:02:32,100
pero no se puede encontrar algún bug maldito, en un pasa / no pasa modelo que es una especie de bien.

43
00:02:32,100 --> 00:02:36,230
>> La idea es que con ese mecanismo se puede ir foco en sus conjuntos de procesadores otras

44
00:02:36,230 --> 00:02:39,530
o dormir o lo que sea que desee enfocar.

45
00:02:39,530 --> 00:02:43,390
Así que darse cuenta de que usted tiene hasta el próximo martes - técnicamente el quinto lunes,

46
00:02:43,390 --> 00:02:50,840
pero es un día de fiesta, por lo que el próximo martes - para cambiar de pasa / no pasa a la inversa graduadas o viceversa.

47
00:02:50,840 --> 00:02:54,450
Y si usted está realmente en el precipicio y están pensando en abandonar por completo,

48
00:02:54,450 --> 00:02:56,440
por favor me coge después de la conferencia o mándenme una nota.

49
00:02:56,440 --> 00:02:59,990
Nos encantaría que al menos charla antes de decir adiós.

50
00:02:59,990 --> 00:03:03,470
Está bien. Así que empezamos a tomar las ruedas de entrenamiento fuera la última vez.

51
00:03:03,470 --> 00:03:06,030
En particular, nos centramos en cadena.

52
00:03:06,030 --> 00:03:09,740
La cadena es algo que se declaró en la biblioteca CS50,

53
00:03:09,740 --> 00:03:14,340
específicamente en ese archivo llamado cs50.h que vamos a empezar a ver esta semana y la próxima.

54
00:03:14,340 --> 00:03:17,250
Pero la cadena es en realidad una simplificación de algo

55
00:03:17,250 --> 00:03:20,980
que es un poco más arcanely descrito como char *.

56
00:03:20,980 --> 00:03:24,090
Charla estamos familiarizados. Es sólo un carácter único.

57
00:03:24,090 --> 00:03:28,010
Pero a partir del lunes * denota qué? >> [Estudiante] Puntero.

58
00:03:28,010 --> 00:03:31,290
Un puntero. Y lo que es un puntero? >> [Estudiante] Una dirección.

59
00:03:31,290 --> 00:03:33,420
>> Es como una dirección, un lugar en la memoria.

60
00:03:33,420 --> 00:03:35,910
¿Qué es una dirección o ubicación o la memoria?

61
00:03:35,910 --> 00:03:40,290
Una vez más, todos nosotros tenemos ordenadores portátiles con un giga o 2 gigas de RAM más probable es que en estos días,

62
00:03:40,290 --> 00:03:44,160
y eso significa que tienes un billón o 2 mil millones de bytes por valor de memoria.

63
00:03:44,160 --> 00:03:46,240
Y no importa lo que físicamente se parece,

64
00:03:46,240 --> 00:03:51,220
pero ten fe en que usted puede contar todos los bytes individuales que tiene su propio ordenador portátil -

65
00:03:51,220 --> 00:03:54,580
este es el byte 0, se trata de un byte, este es el byte 2 mil millones -

66
00:03:54,580 --> 00:03:56,100
y eso es exactamente lo que hace una computadora.

67
00:03:56,100 --> 00:04:00,030
Al asignar espacio para un solo carácter, por ejemplo,

68
00:04:00,030 --> 00:04:02,480
es obvio que tiene que vivir en algún lugar de la memoria del ordenador,

69
00:04:02,480 --> 00:04:05,860
y tal vez es en el byte número 12345,

70
00:04:05,860 --> 00:04:08,470
y que en algún lugar aquí en la memoria de su computadora.

71
00:04:08,470 --> 00:04:12,630
Y a continuación, la dirección de ese carácter es 12345.

72
00:04:12,630 --> 00:04:16,140
>> Ahora, en la semana 0 y ahora hasta el momento, no hemos atendido

73
00:04:16,140 --> 00:04:19,170
donde en las cosas de memoria se almacenan ya que por lo general utilizan símbolos,

74
00:04:19,170 --> 00:04:22,540
variables y matrices para conseguir realmente a nuestros datos.

75
00:04:22,540 --> 00:04:24,950
Pero a partir del lunes y todo el día de hoy más, usted está ahora va a tener

76
00:04:24,950 --> 00:04:27,710
todas las capacidades más expresivos con los programas de escritura

77
00:04:27,710 --> 00:04:31,330
para manipular realmente la memoria de una computadora sin embargo le parezca,

78
00:04:31,330 --> 00:04:33,720
tanto para fines buenos y malos,

79
00:04:33,720 --> 00:04:39,620
errores es un resultado muy común en este punto en el aprendizaje de esta materia.

80
00:04:39,620 --> 00:04:42,460
Pero, ¿qué es lo que realmente significa ser un char *?

81
00:04:42,460 --> 00:04:46,140
Vamos a seguir adelante para atrás - y volveremos a Binky como prometió hoy.

82
00:04:46,140 --> 00:04:48,670
Vayamos a un ejemplo simple aquí.

83
00:04:48,670 --> 00:04:53,060
Déjame guardar este archivo como compare.c, y me dejaron de conseguir un poco de código de plantilla aquí

84
00:04:53,060 --> 00:05:00,490
así como stdio.h, permítanme darme incluyen cs50.h. Voy a acercar hasta allí.

85
00:05:00,490 --> 00:05:05,850
Permítanme empezar a escribir int main, main (void), y ahora quiero hacer algo como esto:

86
00:05:05,850 --> 00:05:13,520
printf ("Dame una cadena:") y luego voy a utilizar la cadena s se GetString

87
00:05:13,520 --> 00:05:16,750
para obtener una cadena por parte del usuario, y luego me voy a preguntar al usuario por otro.

88
00:05:16,750 --> 00:05:21,870
("Dame otra cadena:") y voy a preguntarles por GetString para conseguir eso.

89
00:05:21,870 --> 00:05:27,020
Voy a llamar a t t porque viene después de s y s es un bonito nombre para una cadena si es bastante genérico.

90
00:05:27,020 --> 00:05:30,030
Así GetString, y ahora sólo quiero hacer una comprobación de validez y yo voy a decir

91
00:05:30,030 --> 00:05:39,770
if (s == t), entonces yo voy a decirle al usuario printf ("Usted escribe lo mismo \ n");

92
00:05:39,770 --> 00:05:45,520
más que voy a imprimir algo como ("que ha escrito algo diferente! \ n")

93
00:05:45,520 --> 00:05:48,460
o cualquiera que sea la sentencia será. Así que algo como eso.

94
00:05:48,460 --> 00:05:52,200
Entonces, como de costumbre, voy a devolver 0, lo que sólo significaba que nada malo ha pasado,

95
00:05:52,200 --> 00:05:54,400
y voy a seguir adelante y compilar y ejecutar este programa.

96
00:05:54,400 --> 00:05:56,540
>> Pero el lunes nos encontramos con este programa,

97
00:05:56,540 --> 00:06:00,420
y de hecho se les dijo que no se HOLA hola y adiós no es un adiós.

98
00:06:00,420 --> 00:06:03,140
El comportamiento que vimos fue un poco más de esta manera.

99
00:06:03,140 --> 00:06:11,450
Déjame ir a mi directorio de las fuentes, zoom aquí, y vamos a comparar hacen.

100
00:06:11,450 --> 00:06:14,570
Compilado bien. Déjame correr comparar. Dame una cadena: HOLA.

101
00:06:14,570 --> 00:06:16,300
Dame otra cadena: HOLA.

102
00:06:16,300 --> 00:06:18,000
Ha escrito algo diferente!

103
00:06:18,000 --> 00:06:22,650
Bueno, voy a tratar de algo más simple como 50, 50. Ha escrito algo diferente!

104
00:06:22,650 --> 00:06:25,740
hi, hi. Así que, claramente, algo está pasando aquí.

105
00:06:25,740 --> 00:06:28,440
¿Pero cuál era la explicación de por qué?

106
00:06:28,440 --> 00:06:33,850
Al parecer, la línea 12 es completamente disfuncional.

107
00:06:34,300 --> 00:06:39,430
¿Cuál es el problema fundamental aquí? Si. >> [Estudiante] Se comparan las direcciones.

108
00:06:39,430 --> 00:06:41,850
Sí, exactamente. De hecho, es la comparación de las direcciones

109
00:06:41,850 --> 00:06:44,580
en el cual HOLA HOLA y se almacenan.

110
00:06:44,580 --> 00:06:48,290
No es comparar las cartas HOLA una y otra vez,

111
00:06:48,290 --> 00:06:52,370
porque lo que realmente sucedió, todo este tiempo que hemos estado usando GetString -

112
00:06:52,370 --> 00:06:56,130
Esta pizarra es de nuevo la memoria de nuestro ordenador,

113
00:06:56,130 --> 00:07:00,100
y digamos que yo llamo GetString después de declarar una variable s.

114
00:07:00,100 --> 00:07:01,930
¿Qué hace mi memoria parece?

115
00:07:01,930 --> 00:07:07,070
Vamos a decir que arbitrariamente s se parece a esto. Es un cuadrado.

116
00:07:07,070 --> 00:07:09,040
Y casi todo el tiempo que he dibujado un pedazo de la memoria en la pantalla

117
00:07:09,040 --> 00:07:12,860
si es de 32 bits que he estado dibujando cuadros como este porque de hecho en el aparato,

118
00:07:12,860 --> 00:07:17,380
un puntero, una dirección, es de 32 bits. Es lo mismo que un int.

119
00:07:17,380 --> 00:07:19,420
Eso puede variar basado en el sistema informático.

120
00:07:19,420 --> 00:07:24,630
Aquellos de ustedes que son vagamente familiarizado con el hecho de que tu Mac o PC es de 64 bits,

121
00:07:24,630 --> 00:07:28,120
que en realidad significa que el equipo está utilizando punteros de 64 bits,

122
00:07:28,120 --> 00:07:33,730
Direcciones de 64-bit, y entre los upsides de que los equipos

123
00:07:33,730 --> 00:07:35,560
RAM puede tener mucho más que antaño.

124
00:07:35,560 --> 00:07:39,240
Larga historia corta, de vuelta en el día en que los ordenadores sólo utilizan 32 bits

125
00:07:39,240 --> 00:07:42,740
para representar direcciones, el mayor número de bytes que puede representar

126
00:07:42,740 --> 00:07:46,280
en ese caso era lo que si usted tiene 32 bits?

127
00:07:46,280 --> 00:07:49,590
Así que 4 mil millones, a la derecha, ya que 2 de los 32 es de 4 millones de dólares.

128
00:07:49,590 --> 00:07:51,370
Este número ha sido recurrente en el curso.

129
00:07:51,370 --> 00:07:55,240
>> Así que si usted sólo tiene 32 bits, el número más alto que se puede contar hasta es aproximadamente 4 mil millones.

130
00:07:55,240 --> 00:07:58,750
Pero eso era una limitación fundamental de los ordenadores hasta hace unos años

131
00:07:58,750 --> 00:08:01,180
porque si sólo se puede contar tan alto como 4 mil millones,

132
00:08:01,180 --> 00:08:05,270
no importa si usted compra 8 gigabytes de RAM y hasta 5 gigabytes de RAM;

133
00:08:05,270 --> 00:08:07,780
no se puede contar tan alto, por lo que era inútil.

134
00:08:07,780 --> 00:08:11,430
Sólo se podía acceder a los primeros 3 o 4 gigabytes de memoria de su computadora.

135
00:08:11,430 --> 00:08:14,410
Eso es menos de un problema ahora, y usted puede comprar MacBook Pro y Dells

136
00:08:14,410 --> 00:08:17,680
con 8 gigabytes de RAM o incluso más en estos días.

137
00:08:17,680 --> 00:08:24,100
Pero si simplemente asignar en este programa un puntero, un puntero llamado s,

138
00:08:24,100 --> 00:08:28,370
que podría tener este aspecto en la pantalla porque en realidad tenemos que pelar esta capa.

139
00:08:28,370 --> 00:08:33,520
Sigo diciendo cadena, pero a partir del lunes, la cadena es realmente char *,

140
00:08:33,520 --> 00:08:35,590
la dirección de algún personaje.

141
00:08:35,590 --> 00:08:39,280
Así que vamos a tomar esa rueda de entrenamiento a pesar de que vamos a seguir utilizando GetString por ahora.

142
00:08:39,280 --> 00:08:42,600
Así que he declarado s, y esto es una porción de la memoria, 32 bits.

143
00:08:42,600 --> 00:08:47,370
¿Qué hay aquí en la memoria por defecto? >> [Respuesta de los estudiantes inaudible]

144
00:08:47,370 --> 00:08:50,040
¿Qué es eso? >> [Estudiante] basura. >> Basura. Exactamente.

145
00:08:50,040 --> 00:08:54,610
Si el programador no poner un valor en una variable, que sabe lo que es?

146
00:08:54,610 --> 00:08:57,990
A veces se tiene suerte y es 0, que es una especie de un valor agradable, limpio defecto,

147
00:08:57,990 --> 00:09:00,310
pero como vimos lunes, a veces es una completa tontería,

148
00:09:00,310 --> 00:09:04,130
un número muy grande positivo o negativo que viene de dónde?

149
00:09:05,350 --> 00:09:07,010
Si. >> [Estudiante] La función anterior. Sí >>.

150
00:09:07,010 --> 00:09:10,170
>> A menudo, la función que he llamado antes porque recuerden,

151
00:09:10,170 --> 00:09:13,920
como se llama a funciones de la memoria, que ocupan cada vez más espacio de abajo hacia arriba,

152
00:09:13,920 --> 00:09:17,040
y tan pronto como la función retorna, que la memoria se reutilizan

153
00:09:17,040 --> 00:09:20,890
por el tipo de al lado que se llama, quién está utilizando el mismo segmento de la memoria.

154
00:09:20,890 --> 00:09:23,450
Y si tienes basura izquierda hay, los valores anteriores,

155
00:09:23,450 --> 00:09:28,190
podríamos confundir s como tener algún valor, cuando en realidad no hemos puesto nada allí.

156
00:09:28,190 --> 00:09:30,960
Así que nuestra RAM en este punto se ve así.

157
00:09:30,960 --> 00:09:36,030
Ahora, en el lado derecho de la línea 7 que llamamos GetString,

158
00:09:36,030 --> 00:09:40,150
que hemos estado haciendo durante semanas ahora, pero lo que realmente GetString haciendo?

159
00:09:40,150 --> 00:09:43,350
GetString escrito por el personal CS50 es un poco inteligente

160
00:09:43,350 --> 00:09:46,500
en que tan pronto como el usuario inicia pulsan teclas y parada Intro,

161
00:09:46,500 --> 00:09:50,010
GetString se da cuenta de cómo las pulsaciones de teclas muchos hicieron el hit de usuario,

162
00:09:50,010 --> 00:09:53,360
número de caracteres que tengo que asignará memoria RAM.

163
00:09:53,360 --> 00:09:55,660
¿Y dónde RAM que viene, ¿quién sabe?

164
00:09:55,660 --> 00:09:58,930
Está en algún lugar de 2 gigabytes de su ordenador o lo que sea de la memoria.

165
00:09:58,930 --> 00:10:05,200
Pero vamos a suponer que el equipo encontró espacio para la palabra HOLA aquí.

166
00:10:05,200 --> 00:10:08,710
La palabra que escribí fue H-E-L-L-O.

167
00:10:08,710 --> 00:10:13,510
Y si sacamos esto como una secuencia de caracteres, podríamos llamar así.

168
00:10:13,510 --> 00:10:17,860
Pero tengo que hacer una cosa más. Lo que pertenece al final de cualquier cadena en C?

169
00:10:17,860 --> 00:10:20,710
El carácter nulo, lo que se escribe como \ 0.

170
00:10:20,710 --> 00:10:23,980
Es técnicamente el número 0, pero la barra invertida hace todo más claro

171
00:10:23,980 --> 00:10:28,150
que esto es literalmente el número 0, el número entero 0;

172
00:10:28,150 --> 00:10:32,440
no lo es, por ejemplo, entre comillas 0 que podría escribir en el teclado.

173
00:10:32,440 --> 00:10:33,940
Así que esto es HELLO.

174
00:10:33,940 --> 00:10:36,350
>> ¿Y qué podemos decir hoy que una función como GetString

175
00:10:36,350 --> 00:10:39,580
en realidad está devolviendo todas estas semanas?

176
00:10:39,580 --> 00:10:43,960
No está devolviendo una cadena de por sí, ya que en realidad no tienen significado

177
00:10:43,960 --> 00:10:47,710
porque las cadenas no existen. Son una especie de una fabricación en la biblioteca CS50.

178
00:10:47,710 --> 00:10:51,300
Lo que es realmente una cadena, más técnicamente? >> [Estudiante] Es el primer carácter.

179
00:10:51,300 --> 00:10:55,950
Exactamente. Es, sencillamente, la dirección del primer carácter que el usuario escribió pulg

180
00:10:55,950 --> 00:11:02,810
Así que si mi palabra HOLA termina en 123 el número de bytes y luego en el byte número 124,

181
00:11:02,810 --> 00:11:08,320
125, 126, y así sucesivamente, si tan sólo mi número de bytes en un máximo de 0,

182
00:11:08,320 --> 00:11:12,650
lo que realmente está regresando GetString es, literalmente, el número 123.

183
00:11:12,650 --> 00:11:19,270
Así que lo que se pone en s es el número 123, no la letra H, no la palabra HOLA,

184
00:11:19,270 --> 00:11:23,130
sencillamente, la dirección en la que puedo encontrar la primera letra de HELLO.

185
00:11:23,130 --> 00:11:26,500
Pero eso no parece ser suficiente. Te pedí una cadena, no un personaje.

186
00:11:26,500 --> 00:11:32,970
Entonces, ¿cómo sabe el ordenador o que tipo de ELLO vienen junto con la H?

187
00:11:35,760 --> 00:11:37,460
¿Cuál es el tipo de acuerdo que tenemos? Si.

188
00:11:37,460 --> 00:11:40,100
[Estudiante] Se sigue diciendo sí mismo para encontrar algunos personajes más. >> Exactamente.

189
00:11:40,100 --> 00:11:44,570
>> Hay una convención persona-ordenador por lo que cuando se trata de cadenas,

190
00:11:44,570 --> 00:11:49,410
también conocida ahora como estrellas char, simplemente tienes que saber

191
00:11:49,410 --> 00:11:54,350
donde al final de cada cadena en la vida es realmente sólo iterar sobre ella con un bucle for,

192
00:11:54,350 --> 00:11:57,820
un bucle while, lo que sea, para que cuando encuentre el final de la cadena

193
00:11:57,820 --> 00:12:02,160
ahora se puede inferir de eso, oh, toda la palabra era HELLO.

194
00:12:02,160 --> 00:12:04,820
Aquellos de ustedes que tienen experiencia previa en programación puede saber en Java

195
00:12:04,820 --> 00:12:09,880
usted puede llamar. longitud y en otros idiomas se puede llamar a la longitud o similar.

196
00:12:09,880 --> 00:12:14,060
Eso es porque en una gran cantidad de idiomas, sobre todo cosas que se llaman lenguajes orientados a objetos,

197
00:12:14,060 --> 00:12:18,580
la longitud de algo es de tipo encapsulado dentro de la pieza de datos en sí,

198
00:12:18,580 --> 00:12:24,000
muy parecido a nosotros, los IDs y nombres encapsulados y casas en el interior de un estudiante el lunes.

199
00:12:24,000 --> 00:12:28,700
Sin embargo, C es el nivel mucho más bajo. No hay objetos o clases, si has escuchado esos términos antes.

200
00:12:28,700 --> 00:12:31,490
Todo lo que tienes es realmente direcciones de memoria.

201
00:12:31,490 --> 00:12:35,540
Así que esto es una especie de la manera tradicional de representar las estructuras de datos interesantes.

202
00:12:35,540 --> 00:12:38,760
Tiene un valor de inicio como la dirección del primer carácter

203
00:12:38,760 --> 00:12:42,340
y luego sólo una convención arbitraria que todo el mundo está de acuerdo en seguir.

204
00:12:42,340 --> 00:12:46,420
Entonces, ¿cómo se implementa longitud de la cadena, lo que proponemos?

205
00:12:46,420 --> 00:12:51,360
Strlen, strlen, que algunos de ustedes han usado un par de veces. Es bastante simple, ¿verdad?

206
00:12:51,360 --> 00:12:53,060
Es como dos líneas de código.

207
00:12:53,060 --> 00:12:56,140
Es más o menos un lazo para de algún tipo, tal vez con una variable local adicional.

208
00:12:56,140 --> 00:13:00,540
Pero strlen sólo tiene que echar un puntero y luego empezar a buscar \ 0.

209
00:13:00,540 --> 00:13:05,190
>> Y tan pronto como lo encuentra, puede devolver el número total de pasos que ha tomado en esa cadena.

210
00:13:05,190 --> 00:13:07,150
Así que podemos inferir de esto lo que sucede a continuación.

211
00:13:07,150 --> 00:13:11,850
Supongamos entonces declaro t como lo he hecho en la línea 10.

212
00:13:11,850 --> 00:13:14,280
Este es un valor basura. Quién sabe al principio?

213
00:13:14,280 --> 00:13:18,490
Pero en el lado derecho de la línea de 10 Voy a llamar a GetString nuevo.

214
00:13:18,490 --> 00:13:20,050
¿Quién sabe dónde termina esto?

215
00:13:20,050 --> 00:13:23,830
Vamos a decir arbitrariamente que el sistema operativo se ha encontrado sitio para él hasta aquí.

216
00:13:23,830 --> 00:13:28,610
Sucede que escribir casualmente H-E-L-L-O de nuevo,

217
00:13:28,610 --> 00:13:31,260
y por lo que podemos llamar el mismo tipo de imagen.

218
00:13:31,260 --> 00:13:34,290
Pero el hecho de que he redibujado esta imagen es deliberada

219
00:13:34,290 --> 00:13:37,720
porque es una. diferente HOLA que éste

220
00:13:37,720 --> 00:13:43,920
Así que aquí esta podría ser la ubicación 456, esto es 457, y así sucesivamente.

221
00:13:43,920 --> 00:13:47,170
Así que lo que se pone en el signo de interrogación que una vez fue?

222
00:13:47,170 --> 00:13:50,190
En este caso 456.

223
00:13:50,190 --> 00:13:53,540
Estamos recibiendo estos números arbitrariamente porque realmente a partir de hoy

224
00:13:53,540 --> 00:13:57,110
no vamos a cuidar mucho sobre cuál es la dirección de algo es.

225
00:13:57,110 --> 00:14:02,690
Todo lo que importa es que podemos averiguar la dirección de algún dato como HELLO.

226
00:14:02,690 --> 00:14:07,100
>> Así que en realidad lo que la mayoría de la gente hace en ciencias de la computación cuando se habla de las direcciones de memoria

227
00:14:07,100 --> 00:14:10,210
y hablando de punteros en concreto,

228
00:14:10,210 --> 00:14:14,220
en lugar de preocuparse averiguando 123 - a quién le importa donde este material es en realidad,

229
00:14:14,220 --> 00:14:17,440
solo sabemos que es en alguna dirección numérica -

230
00:14:17,440 --> 00:14:22,180
simplificamos el mundo y decir que s está apuntando a ese personaje

231
00:14:22,180 --> 00:14:25,080
y t se señala a ese carácter.

232
00:14:25,080 --> 00:14:27,430
Y el hecho de que es una flecha es absolutamente intencional

233
00:14:27,430 --> 00:14:31,610
porque, literalmente, ahora s está apuntando a H y T está señalando en el otro H

234
00:14:31,610 --> 00:14:34,720
porque al final del día, no importa lo que la dirección es,

235
00:14:34,720 --> 00:14:40,240
pero sí importa que tengamos la capacidad de expresar esa dirección con alguna pieza de código.

236
00:14:40,240 --> 00:14:42,730
Realmente no hemos manipulado estas direcciones todavía

237
00:14:42,730 --> 00:14:47,770
así que vamos a ver donde podemos intervenir y ordenar de hacer las cosas con punteros,

238
00:14:47,770 --> 00:14:52,030
pero por el momento en la línea 12 literalmente qué valores estamos comparando

239
00:14:52,030 --> 00:14:55,500
de acuerdo con esta historia en la línea 12?

240
00:14:56,570 --> 00:15:01,290
Lo que estamos diciendo es 123 igual igual a 456? Y eso no es definitivamente el caso.

241
00:15:01,290 --> 00:15:05,320
E incluso conceptualmente, este puntero es definitivamente no es el mismo que este

242
00:15:05,320 --> 00:15:09,500
porque GetString llamado dos veces, y GetString no trata de ser super inteligente,

243
00:15:09,500 --> 00:15:12,470
no se trata de darte cuenta, oh, que escribió HOLA hace 5 minutos;

244
00:15:12,470 --> 00:15:15,090
te voy a dar el mismo puntero como que te di antes,

245
00:15:15,090 --> 00:15:18,450
sólo reserva un espacio de memoria cada vez que lo llaman.

246
00:15:18,450 --> 00:15:20,350
>> Entonces, ¿cómo podemos solucionar este problema?

247
00:15:20,350 --> 00:15:24,270
Si un nivel más alto que quiero comparar las cadenas Hola y hola -

248
00:15:24,270 --> 00:15:28,680
No me importan los punteros - ¿Cómo hago para contestar la pregunta,

249
00:15:28,680 --> 00:15:31,980
Por qué el usuario escriba la misma cosa? Lo que se necesita aquí? Si.

250
00:15:31,980 --> 00:15:35,200
[Estudiante] Utilice una función. >> Puedo utilizar una función fuera de la caja.

251
00:15:35,200 --> 00:15:38,170
Puedo utilizar una función llamada strcmp, s-t-r-c-m-p,

252
00:15:38,170 --> 00:15:41,190
sólo la versión abreviada de decir comparación de cadenas.

253
00:15:41,190 --> 00:15:45,070
Y si entramos en, por ejemplo, comparar 2, que es uno de los folletos de hoy,

254
00:15:45,070 --> 00:15:46,690
Hago exactamente eso.

255
00:15:46,690 --> 00:15:51,750
Guardé todo lo demás constante de la línea 1 hasta el 26 o así,

256
00:15:51,750 --> 00:15:54,360
y ahora cuenta de esta parte ha cambiado un poco.

257
00:15:54,360 --> 00:15:57,690
Vamos a pasar por alto la línea 28 por un momento y centrarse sólo en este caso.

258
00:15:57,690 --> 00:16:00,410
¿Qué nos dicen hoy que str comparación hace?

259
00:16:00,410 --> 00:16:05,200
Se maneja el proceso de tomar 2 punteros, S y T en este caso,

260
00:16:05,200 --> 00:16:08,480
tipo de prácticamente poniendo su dedo en esas 2 cartas,

261
00:16:08,480 --> 00:16:11,530
y lo que debe hacer es algo parecido a un bucle while o un bucle for,

262
00:16:11,530 --> 00:16:16,050
y dice que estos son los mismos? Si es así, se mueve los dedos o los punteros hacia adelante.

263
00:16:16,050 --> 00:16:17,970
¿Son los mismos, éstos lo mismo, ellos, el mismo

264
00:16:17,970 --> 00:16:22,710
estos mismo, estos mismo? Y ooh, estoy en el final de la cadena, tanto en s y t.

265
00:16:22,710 --> 00:16:26,780
No he encontrado ninguna contradicción. Sí, estas cadenas son iguales.

266
00:16:26,780 --> 00:16:31,940
¿Y qué str comparar devolución si dos cadenas son iguales, al parecer? Cero.

267
00:16:31,940 --> 00:16:35,900
Así que 0 es bueno en este caso porque si devuelve -1 o +1,

268
00:16:35,900 --> 00:16:40,560
que significa que s le pasa a venir antes o después de t alfabéticamente t.

269
00:16:40,560 --> 00:16:43,760
¿Y por qué tendría que ser útil disponer de una función que le indica qué cadena va antes

270
00:16:43,760 --> 00:16:46,720
o después de que en un diccionario?

271
00:16:46,720 --> 00:16:48,740
[Estudiante] Búsquedas. >> Búsqueda y ordenación.

272
00:16:48,740 --> 00:16:51,730
>> Así que usted puede hacer cosas como búsqueda binaria o tipo burbuja o fusionar especie

273
00:16:51,730 --> 00:16:53,230
donde usted tiene que comparar las cosas.

274
00:16:53,230 --> 00:16:56,420
Hasta ahora hemos especie de cortar algunas esquinas y sólo habló de clasificación

275
00:16:56,420 --> 00:16:59,430
en el contexto de los números, porque es agradable y fácil de hablar,

276
00:16:59,430 --> 00:17:02,430
pero que sin duda puede comparar cadenas, manzana y plátano,

277
00:17:02,430 --> 00:17:05,349
porque si la manzana es conocido por venir antes de plátano, de manera similar,

278
00:17:05,349 --> 00:17:09,319
Puede mover las cadenas en torno a la memoria al igual que hizo con Rob especie de mezcla en el video

279
00:17:09,319 --> 00:17:15,880
y lo hicimos aquí en el escenario con una especie de selección, ordenación por inserción, y una especie de burbuja.

280
00:17:15,880 --> 00:17:18,710
Entonces, ¿dónde más podemos tomar esto? Vamos a probar esto.

281
00:17:18,710 --> 00:17:23,980
Vamos a ordenar de olvidar esa lección por un momento y pruebe y copiar 1.c a hacer lo siguiente.

282
00:17:23,980 --> 00:17:26,800
En la línea 21 que estoy diciendo algo de impresión,

283
00:17:26,800 --> 00:17:28,520
entonces yo estoy haciendo una cadena del usuario,

284
00:17:28,520 --> 00:17:30,690
entonces yo estoy comprobando esto.

285
00:17:30,690 --> 00:17:33,620
Realmente no hemos entrado en esta costumbre todavía, pero ahora vamos a hacer esto.

286
00:17:33,620 --> 00:17:40,990
Vamos a pelar en realidad esta capa. Esto es realmente char *. Este tipo es realmente char *.

287
00:17:40,990 --> 00:17:45,690
Entonces, ¿qué significa estar comprobando si s == NULL?

288
00:17:45,690 --> 00:17:48,380
Resulta que cuando se llama a una función como GetString

289
00:17:48,380 --> 00:17:51,540
o más generalmente sólo pide una computadora para darle un poco de memoria,

290
00:17:51,540 --> 00:17:53,030
algo podría salir mal.

291
00:17:53,030 --> 00:17:56,630
Usted podría estar loco y pedir a la computadora por un terabyte de memoria

292
00:17:56,630 --> 00:18:01,780
pidiendo miles de millones de bytes de memoria que simplemente no existen en el equipo,

293
00:18:01,780 --> 00:18:05,130
pero las funciones GetString y otros necesitan alguna forma de gritarle a usted

294
00:18:05,130 --> 00:18:06,820
si has pedido demasiado.

295
00:18:06,820 --> 00:18:10,450
Y la forma en GetString hace esto es si usted ha pedido más memoria

296
00:18:10,450 --> 00:18:14,250
que está disponible en el equipo, incluso si eso probabilidad super, super bajo

297
00:18:14,250 --> 00:18:17,730
porque ninguno de nosotros va a escribir un billón de caracteres y luego presione Enter,

298
00:18:17,730 --> 00:18:21,980
pero baja probabilidad pesar de que puede ser, yo todavía desea comprobar por si acaso,

299
00:18:21,980 --> 00:18:26,120
y el valor especial que vuelve GetString, respuesta, y otras funciones

300
00:18:26,120 --> 00:18:30,630
si algo ha ido mal es NULL en mayúsculas.

301
00:18:30,630 --> 00:18:36,520
>> ¿Y cuál es NULL? NULL que pasa de representar un puntero. Es la dirección de memoria 0.

302
00:18:36,520 --> 00:18:40,800
El mundo arbitrariamente decidió que, si se trata de la memoria de mi ordenador - ¿sabes qué? -

303
00:18:40,800 --> 00:18:46,260
vamos a robar a sólo 1 byte de memoria cada equipo, y ésta es la posición 0.

304
00:18:46,260 --> 00:18:49,560
Vamos a darle un apodo de NULL, y vamos a prometer

305
00:18:49,560 --> 00:18:52,660
que en realidad nunca poner los datos reales no

306
00:18:52,660 --> 00:18:56,770
porque simplemente arbitrariamente necesita un valor especial, 0, NULL aka,

307
00:18:56,770 --> 00:19:00,230
para que podamos gritar a los usuarios si algo sale mal.

308
00:19:00,230 --> 00:19:03,590
De lo contrario usted puede no saber qué decir 0 poner algo aquí

309
00:19:03,590 --> 00:19:05,490
o significa algo salió mal?

310
00:19:05,490 --> 00:19:09,190
Tenemos que estar de acuerdo todo lo que no significa nada NULL fue devuelto,

311
00:19:09,190 --> 00:19:11,700
sin dirección real fue devuelto.

312
00:19:11,700 --> 00:19:15,210
Ahora, aquí estoy adoptando mi convención humana de regreso de un principal

313
00:19:15,210 --> 00:19:17,040
si algo sale mal.

314
00:19:17,040 --> 00:19:20,650
Esto se debe a la convención principal de retorno es devolver 0 si bien,

315
00:19:20,650 --> 00:19:22,990
1 o algún otro valor si es mala.

316
00:19:22,990 --> 00:19:28,200
Pero GetString y cualquier otra función que se ocupa de los rendimientos de memoria NULL si algo sale mal.

317
00:19:28,200 --> 00:19:33,480
>> Bien. Así que, lamentablemente, la línea 27, super simple que sea, no puede copiar completamente la cadena.

318
00:19:33,480 --> 00:19:35,740
¿Por qué? Podemos ver esto como sigue.

319
00:19:35,740 --> 00:19:40,120
Estoy reclamando en la línea 27 se hace una copia de s y decir que es t.

320
00:19:40,120 --> 00:19:45,790
Así que no estoy preguntando al usuario por 2 cadenas en esta ocasión, sólo estoy diciendo que el valor en s

321
00:19:45,790 --> 00:19:47,870
debe ser puesto en t también.

322
00:19:47,870 --> 00:19:52,890
Así que ahora sólo para demostrar cómo rota esto es, en la línea 29 en adelante ¿qué estoy haciendo?

323
00:19:52,890 --> 00:19:56,980
En primer lugar estoy comprobando si la longitud de t es mayor que 0.

324
00:19:56,980 --> 00:19:59,330
Hay un poco de cuerda allí. El usuario escribe algo pulg

325
00:19:59,330 --> 00:20:03,410
¿Cuál es la línea 32 hace, al parecer?

326
00:20:03,410 --> 00:20:08,910
[Respuesta de los estudiantes inaudible] Derecho. >> Se puede inferir de la misma especie a partir de lo que he dicho que está haciendo.

327
00:20:08,910 --> 00:20:13,200
Pero, técnicamente, lo que se esta haciendo? t [0] representa qué?

328
00:20:13,200 --> 00:20:15,140
[Estudiante] El carácter cero. >> [Malan] El carácter cero.

329
00:20:15,140 --> 00:20:19,620
O, más parecidos a los humanos, el primer carácter en t, sea lo que sea, H tal vez en este caso.

330
00:20:19,620 --> 00:20:24,990
Y toupper hace lo que dice. Se aprovecha el carácter cero de toneladas y lo cambia.

331
00:20:24,990 --> 00:20:28,430
Así que esto significa tomar el carácter cero de t, lo convierten en mayúsculas,

332
00:20:28,430 --> 00:20:30,320
y poner de nuevo en ese mismo lugar.

333
00:20:30,320 --> 00:20:35,540
Así que si yo escriba hello en minúsculas, esto debe cambiar la h minúscula a mayúscula H.

334
00:20:35,540 --> 00:20:41,400
Pero el problema es que en las líneas 35 y 36, lo que voy a hacer es imprimir para nosotros s y t.

335
00:20:41,400 --> 00:20:43,120
¿Y cuál es tu corazonada?

336
00:20:43,120 --> 00:20:47,250
¿Qué es lo que realmente va a ver si he escrito en hola en minúsculas?

337
00:20:47,250 --> 00:20:52,280
¿Qué va a quedar impreso? >> [Respuesta de los estudiantes inaudible] >> ¿Qué es eso?

338
00:20:52,280 --> 00:20:58,360
[Estudiante] Big H y el resto pequeñas. >> La gran H y el resto pequeño para que, s o t?

339
00:20:58,360 --> 00:21:03,170
[Estudiante] Las dos cosas. Ambos >>. Exactamente. Así que vamos a ver lo que está pasando aquí.

340
00:21:03,170 --> 00:21:08,380
>> Déjenme seguir adelante y compilar esto. Esto es copy1, así que copia1. Está bien.

341
00:21:08,380 --> 00:21:14,840
Zoom in Déjame seguir adelante y ejecutar copy1, Intro, Decir algo: hola en minúsculas.

342
00:21:14,840 --> 00:21:19,570
Se capitaliza la copia, pero al parecer capitalizan el original y,

343
00:21:19,570 --> 00:21:22,070
porque lo que ahora sucede en esta historia?

344
00:21:22,070 --> 00:21:27,030
En la línea 27 que en realidad no parece estar copiando la cadena,

345
00:21:27,030 --> 00:21:30,450
pero a pesar de que podría haber esperado intuitivamente que ese sea el caso,

346
00:21:30,450 --> 00:21:33,680
si usted piensa acerca de esta foto, lo que realmente he hecho?

347
00:21:33,680 --> 00:21:35,410
La mitad de la imagen es el mismo.

348
00:21:35,410 --> 00:21:39,390
Así que vamos a retroceder en el tiempo para que t todavía no existe en la historia.

349
00:21:39,390 --> 00:21:43,160
S puede existir en la historia, pero vamos a minúsculas hola este momento.

350
00:21:43,160 --> 00:21:46,710
Así que vamos a arreglar lo que en realidad escrito pulg

351
00:21:46,710 --> 00:21:51,280
En este caso aquí tenemos h-e-l-l-o.

352
00:21:51,280 --> 00:21:58,050
Vamos a dibujar como una secuencia de caracteres, puse las líneas de separación aquí y mi 0 \.

353
00:21:58,050 --> 00:22:05,980
Así que aquí es donde somos tan pronto como la línea 1 a la 24-ish, más o menos, se han ejecutado.

354
00:22:05,980 --> 00:22:07,800
Esta es la foto de mi memoria.

355
00:22:07,800 --> 00:22:10,800
Cuando llego a la línea 27, que pasa?

356
00:22:10,800 --> 00:22:14,730
Al igual que antes, aparece un puntero, lo que voy a dibujar como esta plaza.

357
00:22:14,730 --> 00:22:19,740
Se llama t. ¿Y cuál es su valor por defecto? ¿Quién sabe? Algunos valores de basura.

358
00:22:19,740 --> 00:22:22,060
>> Así que me voy abstracto que fuera como un signo de interrogación.

359
00:22:22,060 --> 00:22:27,670
Y tan pronto como el lado derecho de la línea 27 se ejecuta, lo que me pone dentro de t?

360
00:22:27,670 --> 00:22:30,770
Lo mismo que hay en s.

361
00:22:30,770 --> 00:22:34,120
Así que si por un momento retirar esa abstracción de la flecha y decimos,

362
00:22:34,120 --> 00:22:40,330
oh, esta es la dirección de memoria de carga 123, cuando dices t consigue s, punto y coma,

363
00:22:40,330 --> 00:22:42,700
que está literalmente poniendo 123 aquí.

364
00:22:42,700 --> 00:22:45,200
Ahora si que tipo de simplificar nuestro mundo de nuevo con los cuadros,

365
00:22:45,200 --> 00:22:48,750
lo que ha hecho en realidad se acaba de agregar otra flecha en su mundo

366
00:22:48,750 --> 00:22:52,910
que está señalando de t en la cadena exactamente el mismo.

367
00:22:52,910 --> 00:22:59,730
Por eso, cuando en la línea 31 y 32 que van realmente sobre el cambio de t [0],

368
00:22:59,730 --> 00:23:05,580
lo que es t [0] al parecer sinónimo de ahora? s [0]

369
00:23:05,580 --> 00:23:07,030
Así que eso es todo lo que está pasando.

370
00:23:07,030 --> 00:23:09,900
Y aunque este tipo de se siente un poco bajo nivel y arcano

371
00:23:09,900 --> 00:23:12,760
y este tipo de se siente como quizás intuitivamente esto debería haber sólo funcionaba -

372
00:23:12,760 --> 00:23:15,410
He hecho copias de cosas antes y ha funcionado -

373
00:23:15,410 --> 00:23:18,590
si usted realmente piensa acerca de lo que realmente es una cadena, es un char *.

374
00:23:18,590 --> 00:23:21,700
Bueno, ¿qué es eso? Es la dirección de algún personaje.

375
00:23:21,700 --> 00:23:24,930
Entonces, tal vez tiene más sentido que cuando se trata de hacer algo

376
00:23:24,930 --> 00:23:29,220
súper aparentemente simple como esto, todo lo que estamos haciendo es copiar una dirección de memoria.

377
00:23:29,220 --> 00:23:32,530
Usted no está haciendo nada con la propia cadena.

378
00:23:32,530 --> 00:23:37,500
Así que incluso si usted no tiene idea de cómo se podría resolver este problema en el código,

379
00:23:37,500 --> 00:23:45,080
alto nivel, conceptualmente, ¿qué es lo que tenemos que hacer para que ta copia fiel de s, al parecer?

380
00:23:46,670 --> 00:23:48,820
Si. >> [Estudiante] Le daría una nueva ubicación? >> Exactamente.

381
00:23:48,820 --> 00:23:50,800
>> Tenemos que dar a t un lugar completamente nuevo.

382
00:23:50,800 --> 00:23:55,230
Tenemos que crear de alguna manera un mundo en el que tenemos un espacio de memoria,

383
00:23:55,230 --> 00:24:00,090
que sólo por razones de claridad voy a llamar justo debajo de éste, pero no tiene por qué estar allí.

384
00:24:00,090 --> 00:24:04,880
Pero tiene que ser del mismo tamaño, así que voy a dibujar estas líneas verticales en el mismo lugar.

385
00:24:04,880 --> 00:24:09,720
Está muy bien si esto es todo basura inicialmente. ¿Quién sabe qué estaba allí?

386
00:24:09,720 --> 00:24:13,850
Pero el paso 1 se va a tener que darme tanta memoria como que necesito

387
00:24:13,850 --> 00:24:18,630
para adaptarse a una copia de hola, a continuación, encontrar la manera de copiar el h aquí, el correo aquí,

388
00:24:18,630 --> 00:24:20,390
el l aquí y así sucesivamente.

389
00:24:20,390 --> 00:24:24,880
Pero esto ya se debe sentir un poco obvio, aunque algunos de los detalles son todavía abstracto.

390
00:24:24,880 --> 00:24:28,690
Para copiar esta cadena en este, es sólo un bucle for o while

391
00:24:28,690 --> 00:24:31,580
o algo con lo que te has convertido en lo más familiar.

392
00:24:31,580 --> 00:24:35,970
Así que vamos a probar esto. Déjame entrar en copy2.c.

393
00:24:35,970 --> 00:24:43,270
En copy2.c tenemos casi el mismo programa, a excepción de la línea 27.

394
00:24:43,270 --> 00:24:47,260
Se parece un poco complejo, pero si se descomponen poco a poco,

395
00:24:47,260 --> 00:24:48,950
el lado izquierdo es el mismo.

396
00:24:48,950 --> 00:24:52,790
Char * t crea esta cosa en la memoria, aunque con un signo de interrogación

397
00:24:52,790 --> 00:24:54,680
porque no tenemos ni idea de lo que hay por defecto.

398
00:24:54,680 --> 00:24:57,920
En el lado derecho estamos ahora la introducción de una nueva función malloc,,

399
00:24:57,920 --> 00:25:00,640
para asignar memoria, dame la memoria,

400
00:25:00,640 --> 00:25:06,900
y al parecer se cuántos argumentos, cuántas cosas entre paréntesis?

401
00:25:09,660 --> 00:25:12,130
Oí murmullos de 1 y 2, pero es sólo 1.

402
00:25:12,130 --> 00:25:15,320
No hay una coma, lo que significa que sólo hay una cosa dentro de los paréntesis.

403
00:25:15,320 --> 00:25:17,720
A pesar de que hay otros paréntesis, quisiera destacar

404
00:25:17,720 --> 00:25:21,460
lo que hay dentro de los paréntesis más externos, y es esta expresión:

405
00:25:21,460 --> 00:25:25,880
(Strlen (s) + 1) * sizeof (char).

406
00:25:25,880 --> 00:25:29,190
Así que si realmente pensar en esto, esto está diciendo dame la longitud de s.

407
00:25:29,190 --> 00:25:34,440
¿Por qué soy, sin embargo, añadir 1 a la longitud? >> [Respuesta de los estudiantes inaudible]

408
00:25:34,440 --> 00:25:40,200
Exactamente. Necesitamos espacio para este tipo de la cola, el sexto personaje que no tiene ningún significado Inglés

409
00:25:40,200 --> 00:25:42,250
pero tiene un significado especial programático.

410
00:25:42,250 --> 00:25:46,800
>> Así que necesitamos un + 1 para eso porque strlen Devuelve la expectativa humana de longitud,

411
00:25:46,800 --> 00:25:50,890
hola o 5, no le da el carácter nulo adicional.

412
00:25:50,890 --> 00:25:52,980
Así que agregar manualmente este con + 1.

413
00:25:52,980 --> 00:25:56,060
Y después de esto, de tamaño * (char), no hemos visto esto antes.

414
00:25:56,060 --> 00:25:57,480
Esto no es técnicamente una función.

415
00:25:57,480 --> 00:26:04,150
Es una palabra clave especial que sólo te dice lo que el tamaño es de otro tipo de datos en un ordenador

416
00:26:04,150 --> 00:26:06,980
porque en realidad, algunos de nosotros tenemos equipos de 32 bits.

417
00:26:06,980 --> 00:26:10,900
Tengo un ordenador bastante antiguo en el país, y que sólo utiliza 32 bits para representar los punteros.

418
00:26:10,900 --> 00:26:13,900
Y si lo hacía tamaño de un tipo de datos, puede ser de 32 bits.

419
00:26:13,900 --> 00:26:18,300
Pero si estoy usando mi computadora nueva fantasía, que podría volver un valor de 64 bits

420
00:26:18,300 --> 00:26:20,510
algo así como una dirección.

421
00:26:20,510 --> 00:26:25,400
Así que en este caso, sólo para estar seguro super, no vamos a codificar algo como -

422
00:26:25,400 --> 00:26:28,740
así, ¿cuál es el tamaño de un char de acuerdo con lo que hemos dicho hasta ahora?

423
00:26:28,740 --> 00:26:34,450
Hemos prácticamente me dijo verbalmente que se trata de un byte, y eso es bastante cierto en todos los ámbitos.

424
00:26:34,450 --> 00:26:37,000
Pero, de nuevo, los supuestos tienden a ser malo.

425
00:26:37,000 --> 00:26:40,850
Conducen a software defectuoso si las personas usan su software de maneras que no pensaba.

426
00:26:40,850 --> 00:26:44,750
Así que vamos a abstraer esta lejos y más justo decir genéricamente

427
00:26:44,750 --> 00:26:46,830
Necesito esto muchos trozos de la memoria

428
00:26:46,830 --> 00:26:50,210
y cada trozo de memoria debería ser equivalente al tamaño de un carácter,

429
00:26:50,210 --> 00:26:54,870
que de hecho es igual a 1 en este caso, pero es una forma más genérica de escribir.

430
00:26:54,870 --> 00:27:00,460
Así que si la palabra es hola, cuántos bytes se malloc aparentemente asignar a saludar?

431
00:27:00,460 --> 00:27:04,980
[Estudiante] Seis. >> Six. Exactamente como muchos ya que tenemos signos de interrogación en la pantalla.

432
00:27:04,980 --> 00:27:07,800
Y luego tomar una conjetura ahora se basa en la comprensión de GetString

433
00:27:07,800 --> 00:27:12,790
¿qué malloc probablemente regrese? >> [Estudiante] Una dirección.

434
00:27:12,790 --> 00:27:17,020
Una dirección de qué? Por el primer fragmento de memoria.

435
00:27:17,020 --> 00:27:20,670
>> No tenemos idea de lo que está allí porque alguna otra función

436
00:27:20,670 --> 00:27:23,010
podría haber estado utilizando esta memoria previamente.

437
00:27:23,010 --> 00:27:28,380
Pero malloc, como GetString, devuelve la dirección del primer byte de la memoria

438
00:27:28,380 --> 00:27:30,540
que se ha reservado para usted.

439
00:27:30,540 --> 00:27:38,380
Sin embargo, lo que no hace es rellenar el espacio en blanco con un carácter nulo barra invertida

440
00:27:38,380 --> 00:27:43,030
porque resulta que usted puede utilizar malloc para asignar cualquier cosa: enteros, cadenas, matrices,

441
00:27:43,030 --> 00:27:45,700
flotadores, estructuras estudiantiles.

442
00:27:45,700 --> 00:27:47,750
Puede utilizar malloc totalmente genérica.

443
00:27:47,750 --> 00:27:51,470
No le importa ni tiene que saber lo que la asignación de memoria para.

444
00:27:51,470 --> 00:27:55,810
Así que sería presuntuoso para malloc poner un 0 \

445
00:27:55,810 --> 00:27:58,340
al final de cada trozo de memoria que te está dando

446
00:27:58,340 --> 00:28:02,620
porque \ 0 cosa es sólo una convención para las cadenas.

447
00:28:02,620 --> 00:28:06,310
No se usa para enteros, no se utiliza para los flotadores, no se utiliza para los estudiantes.

448
00:28:06,310 --> 00:28:11,730
Y así el gotcha con malloc es que la carga es totalmente de usted al programador

449
00:28:11,730 --> 00:28:16,790
para recordar la cantidad de bytes que asignan y no utilizar nunca un bucle for

450
00:28:16,790 --> 00:28:21,570
o un bucle while e ir más allá del límite de la cantidad de memoria que han dado.

451
00:28:21,570 --> 00:28:23,540
En otras palabras, tan pronto como se asigna memoria,

452
00:28:23,540 --> 00:28:28,510
no se puede pedir al sistema operativo, oh, por cierto, qué tan grande de un trozo de memoria fue esto?

453
00:28:28,510 --> 00:28:32,080
Es totalmente de usted para recordar si usted necesita ese valor.

454
00:28:32,080 --> 00:28:34,330
>> Así que vamos a ver cómo procedo a utilizar esta memoria.

455
00:28:34,330 --> 00:28:38,430
En la línea 28 y 29 ¿por qué estoy haciendo esto?

456
00:28:39,850 --> 00:28:42,260
Sólo tienes que comprobar la cordura total.

457
00:28:42,260 --> 00:28:45,110
Sólo en caso de que algo iba mal, pido algo increíble cantidad de memoria

458
00:28:45,110 --> 00:28:48,690
o tengo tantas cosas que se ejecuta en el equipo que simplemente no hay suficiente memoria,

459
00:28:48,690 --> 00:28:51,780
algo así, yo por lo menos desea comprobar nula.

460
00:28:51,780 --> 00:28:55,260
En realidad, la mayoría de las computadoras le dará la ilusión de que todos los programas

461
00:28:55,260 --> 00:28:57,080
Puede utilizar la totalidad de la memoria RAM,

462
00:28:57,080 --> 00:29:00,740
pero aún así, si el usuario escribe en una cuerda larga loco tal vez porque eres un chico malo

463
00:29:00,740 --> 00:29:03,440
y en realidad están tratando de bloquear el programa o truco en ella,

464
00:29:03,440 --> 00:29:07,300
desea comprobar al menos el valor de retorno de malloc y si es igual a null.

465
00:29:07,300 --> 00:29:11,630
Y si lo hace, vamos a dejar de fumar en este momento porque no sé qué hacer en ese caso.

466
00:29:11,630 --> 00:29:13,950
¿Cómo puedo copiar la cadena? Hay algunas maneras de hacer esto.

467
00:29:13,950 --> 00:29:18,850
Hay str copiar funciones en C, pero es muy sencillo para nosotros hacer esto la manera antigua.

468
00:29:18,850 --> 00:29:23,110
>> En primer lugar vamos a averiguar cuál es la longitud de s es.

469
00:29:23,110 --> 00:29:26,930
Yo podría haber puesto esto en el bucle, pero en lugar de eso sólo hay que poner aquí para mayor claridad.

470
00:29:26,930 --> 00:29:30,610
Así n ahora almacena la longitud de la cadena original, que aparentemente es 5.

471
00:29:30,610 --> 00:29:35,290
Luego, en mi bucle para iterar desde que estoy en 0 hasta n,

472
00:29:35,290 --> 00:29:40,940
y en cada iteración estoy poniendo s [i] dentro de la [i].

473
00:29:40,940 --> 00:29:45,060
Así que eso es lo que implicaba con mis dos dedos apuntando a las cuerdas antes.

474
00:29:45,060 --> 00:29:49,260
Como este bucle for itera así, yo voy a estar copiando h en aquí,

475
00:29:49,260 --> 00:29:52,890
e en aquí, yo en aquí porque este es s, este es t.

476
00:29:52,890 --> 00:29:58,770
Y por último, en la línea 35 ¿por qué estoy haciendo esto?

477
00:29:58,770 --> 00:30:03,770
Tengo que asegurarme de que estoy terminando la cadena t.

478
00:30:03,770 --> 00:30:06,170
Y lo hizo de esta manera a ser súper explícito.

479
00:30:06,170 --> 00:30:09,510
Pero proponer a alguien, si pudiera, una forma diferente de hacer esto.

480
00:30:09,510 --> 00:30:13,930
Yo realmente no necesita la línea 35. Hay otra manera de hacer esto.

481
00:30:13,930 --> 00:30:18,880
Si. >> [Respuesta de los estudiantes inaudible] >> Dilo fuerte.

482
00:30:18,880 --> 00:30:20,960
[Estudiante] Menor o igual a. >> Exactamente.

483
00:30:20,960 --> 00:30:24,450
Podríamos decir inferior o igual a n, que en general ha sido mal

484
00:30:24,450 --> 00:30:28,190
porque casi siempre cuando subimos a un igual a lo que estamos contando

485
00:30:28,190 --> 00:30:30,000
vamos un paso demasiado lejos.

486
00:30:30,000 --> 00:30:32,170
Pero recuerde, la cantidad de bytes que se asignan?

487
00:30:32,170 --> 00:30:37,210
Se asignaron de strlen s, por lo que 5 + 1 para un total de 6.

488
00:30:37,210 --> 00:30:39,980
Así que en este caso podríamos hacer algo como esto

489
00:30:39,980 --> 00:30:46,450
por lo que estamos copiando no sólo el saludo sino también el 0 \ al final.

490
00:30:46,450 --> 00:30:49,860
Alternativamente, podríamos usar una función llamada str copia, strcpy,

491
00:30:49,860 --> 00:30:51,700
pero que no sería divertido casi como mucho.

492
00:30:51,700 --> 00:30:54,000
Pero eso es todo lo que hace por debajo de la capucha.

493
00:30:54,000 --> 00:30:56,050
A continuación, por último, hacemos lo mismo que antes.

494
00:30:56,050 --> 00:31:01,620
Yo t capitalizar y luego me dicen que el original están presentes y la copia es así.

495
00:31:01,620 --> 00:31:08,570
Así que vamos a tratar ahora. Déjame aquí. Hacer copy2. Vamos a ampliar y ejecutar copy2.

496
00:31:08,570 --> 00:31:13,840
Voy a escribir hola en minúsculas, y de hecho tengo minúsculas hola que el original

497
00:31:13,840 --> 00:31:16,930
pero el capital Hola para la copia.

498
00:31:16,930 --> 00:31:20,300
Pero no he terminado todavía. Tengo que hacer una última cosa aquí.

499
00:31:20,300 --> 00:31:28,000
46 y 47 está claramente cómo liberar memoria, pero ¿qué significa eso realmente?

500
00:31:28,000 --> 00:31:33,250
¿Qué estoy haciendo, ¿crees que, llamando a la línea 46 y la línea 47?

501
00:31:33,250 --> 00:31:38,900
¿Qué efecto tiene eso? Si.

502
00:31:38,900 --> 00:31:43,140
[Respuesta de los estudiantes inaudible] >> Exactamente.

503
00:31:43,140 --> 00:31:46,380
>> Usted se acaba de decirle al sistema operativo, hey, gracias por este recuerdo.

504
00:31:46,380 --> 00:31:48,320
Ahora puede utilizar para otra persona.

505
00:31:48,320 --> 00:31:50,790
Y aquí está un ejemplo perfecto de los valores de basura.

506
00:31:50,790 --> 00:31:55,430
Acabo de utilizar esta memoria para escribir la palabra hola en 2 lugares,

507
00:31:55,430 --> 00:31:57,490
aquí, aquí, aquí y aquí.

508
00:31:57,490 --> 00:32:00,910
Así que este es h-e-l-l-o-\ 0.

509
00:32:00,910 --> 00:32:06,960
Pero entonces llame a la línea 46 y la línea 47, y ya sabes lo que pasa allí en términos de la imagen?

510
00:32:06,960 --> 00:32:10,010
En realidad, esperar, esta imagen es la antigua.

511
00:32:10,010 --> 00:32:12,550
Una vez que la copia sea, este hombre está apuntando aquí,

512
00:32:12,550 --> 00:32:16,110
así que vamos a quitar los números y sólo abstraer como nuestras flechas de nuevo.

513
00:32:16,110 --> 00:32:19,370
¿Qué sucede en este cuadro cuando llamo libre?

514
00:32:19,370 --> 00:32:22,750
[Respuesta de los estudiantes inaudible] >> Ni siquiera.

515
00:32:22,750 --> 00:32:29,510
Si llamo gratis en s y t - una especie de pregunta capciosa - este panorama no cambia en absoluto

516
00:32:29,510 --> 00:32:33,880
porque llamando y llamando s t le dice al sistema operativo,

517
00:32:33,880 --> 00:32:39,010
hey, usted puede utilizar esta memoria de nuevo, pero eso no cambia este valor nulo

518
00:32:39,010 --> 00:32:41,840
o algún carácter especial, no cambia esto,

519
00:32:41,840 --> 00:32:47,350
no cambia el h o e el o la l o l o el o ya sea en el lugar para cualquier otra cosa.

520
00:32:47,350 --> 00:32:51,610
En cuanto a la imagen, tan pronto como se llame cambios libres, nada.

521
00:32:51,610 --> 00:32:56,570
Y ahí está el origen de los valores de basura porque si luego más adelante en este programa

522
00:32:56,570 --> 00:33:01,010
hacer que el sistema operativo para obtener más memoria con malloc o GetString o algo por el estilo

523
00:33:01,010 --> 00:33:04,900
y el sistema operativo dice, claro, tengo 12 bytes de memoria sólo liberados,

524
00:33:04,900 --> 00:33:08,080
utilizar estos, ¿qué vas a ser entregado?

525
00:33:08,080 --> 00:33:10,830
Usted va a ser entregado un trozo de memoria que normalmente se basaría

526
00:33:10,830 --> 00:33:13,700
con signos de interrogación, pero ¿cuáles son los signos de interrogación?

527
00:33:13,700 --> 00:33:17,000
Que se encuentren h-e-l-l-o, h-e-l-l-o.

528
00:33:17,000 --> 00:33:20,940
Estos son nuestros valores nuevos de basura tan pronto como liberar esa memoria.

529
00:33:20,940 --> 00:33:22,750
>> Hay una implicación mundo real aquí también.

530
00:33:22,750 --> 00:33:24,720
Esto sucede que ver con la RAM, pero los equipos

531
00:33:24,720 --> 00:33:26,720
en realidad hacen lo mismo con el disco.

532
00:33:26,720 --> 00:33:30,620
Hablaremos de esto en particular con un conjunto de problemas futuros que se centra en la medicina forense.

533
00:33:30,620 --> 00:33:36,170
Pero lo que realmente sucede si tiene algún archivo financiera sensible en el escritorio

534
00:33:36,170 --> 00:33:39,600
o alguna vaga JPEG y lo arrastra en su basura,

535
00:33:39,600 --> 00:33:44,390
lo que pasa cuando lo arrastra a la basura o la papelera de reciclaje?

536
00:33:44,390 --> 00:33:47,240
Usted sabía lo que estaba hablando. [Risas]

537
00:33:47,240 --> 00:33:52,370
¿Qué sucede cuando se ha arrastrado tales documentos a la papelera de reciclaje o bote de basura?

538
00:33:52,370 --> 00:33:55,920
[Respuesta de los estudiantes inaudible]

539
00:33:55,920 --> 00:33:58,000
Bueno, así que ten cuidado. ¿Qué sucede cuando usted hace eso?

540
00:33:58,000 --> 00:34:01,030
La respuesta corta es no, ¿verdad?

541
00:34:01,030 --> 00:34:04,790
Expediente incompleto o sensible todavía allí sentado en algún lugar de su disco duro.

542
00:34:04,790 --> 00:34:07,940
La mayoría de nosotros por lo menos hemos aprendido por las malas que es necesario vaciar la basura

543
00:34:07,940 --> 00:34:10,429
o la papelera de reciclaje para eliminar realmente los archivos.

544
00:34:10,429 --> 00:34:13,440
Y, en efecto, al hacer clic o clic con el botón de control en el bote de basura

545
00:34:13,440 --> 00:34:15,580
o seleccione Archivo, Vaciar papelera o lo que sea

546
00:34:15,580 --> 00:34:21,420
y que en realidad vaciar la papelera o papelera de reciclaje, lo que realmente sucede entonces con esta imagen?

547
00:34:22,810 --> 00:34:25,969
Más nada. Así que nada sucede realmente en el disco.

548
00:34:25,969 --> 00:34:30,880
>> Y si sólo temporalmente divagar y escribir - I'Ll sólo tiene que utilizar la parte de atrás de esto.

549
00:34:30,880 --> 00:34:34,639
Así que ahora la historia está cambiando de RAM, que es donde existen programas

550
00:34:34,639 --> 00:34:39,250
mientras está en funcionamiento, el disco, que es donde se almacenan a largo plazo

551
00:34:39,250 --> 00:34:42,920
incluso cuando se va la luz, por ahora - y volveremos a ello en el futuro -

552
00:34:42,920 --> 00:34:46,380
vamos a pretender que esto representa el interior del disco duro de su ordenador

553
00:34:46,380 --> 00:34:50,110
porque en su día lo que solía ser discos circulares, al igual que los disquetes.

554
00:34:50,110 --> 00:34:55,130
Así que si usted tiene un poco de sensibilidad archivo de Excel, puede tardar hasta este trozo de memoria

555
00:34:55,130 --> 00:34:59,770
en el disco de su computadora, y estoy dibujando 1s y 0s mismo arbitrario.

556
00:34:59,770 --> 00:35:03,970
Al arrastrar el archivo al igual que a su bote de basura o la papelera de reciclaje,

557
00:35:03,970 --> 00:35:07,750
literalmente no pasa nada, ya que Apple y Microsoft acaba de decidir

558
00:35:07,750 --> 00:35:10,450
la papelera y papelera de reciclaje es en realidad un marcador de posición temporal.

559
00:35:10,450 --> 00:35:14,710
Tal vez, finalmente, el sistema operativo se vaciarlo para usted, pero por lo general, no hace nada,

560
00:35:14,710 --> 00:35:17,090
al menos hasta que estés realmente poco espacio.

561
00:35:17,090 --> 00:35:20,870
>> Sin embargo, cuando se va a la basura vacía o vacía la papelera de reciclaje,

562
00:35:20,870 --> 00:35:23,460
Del mismo modo, no ocurre nada a esta imagen.

563
00:35:23,460 --> 00:35:28,590
Todo lo que sucede está en otro lugar en el equipo, hay una especie de mesa.

564
00:35:28,590 --> 00:35:35,400
Es algo así como una hoja de trucos poco que dice que, digamos, resume.doc,

565
00:35:35,400 --> 00:35:40,920
por lo que su hoja de vida en un archivo de Microsoft Word solía vivir en el lugar 123 en el disco duro,

566
00:35:40,920 --> 00:35:43,710
no en la memoria y no en la memoria RAM, pero en su disco duro,

567
00:35:43,710 --> 00:35:49,050
y sus vidas incompletas JPEG con 456, y el archivo de Excel vive en 789 o donde sea.

568
00:35:49,050 --> 00:35:53,640
Al eliminar archivos en realidad vaciar la basura o la papelera de reciclaje,

569
00:35:53,640 --> 00:35:59,530
esta imagen no cambia. La 0s y 1s en su disco duro no van a ninguna parte.

570
00:35:59,530 --> 00:36:03,930
Pero esta mesa, esta base de datos poco de suerte, sí cambia.

571
00:36:03,930 --> 00:36:08,750
Al eliminar su hoja de vida, es como si el archivo se elimina en cierto sentido,

572
00:36:08,750 --> 00:36:12,790
pero todo el equipo no se olvide que lo que vive en su disco duro.

573
00:36:12,790 --> 00:36:17,870
El 0 y 1 que componen su hoja de vida o de cualquiera de estos archivos se encuentran aún intactos.

574
00:36:17,870 --> 00:36:21,960
>> Así que si usted lo hizo accidentalmente, todavía hay una probabilidad distinta de cero

575
00:36:21,960 --> 00:36:25,800
que usted puede recuperar sus datos utilizando Norton Utilities o algún software comercial

576
00:36:25,800 --> 00:36:29,810
cuyo propósito en la vida es encontrar 0s y 1s que han quedado huérfanos a causa del tipo,

577
00:36:29,810 --> 00:36:33,300
olvidado aquí, pero salió de aquí, para que pueda recuperar los datos.

578
00:36:33,300 --> 00:36:38,410
O los investigadores forenses con la policía o el FBI en realidad tendría un disco duro

579
00:36:38,410 --> 00:36:42,550
y realmente buscar patrones de 0s y 1s que se parecen a imágenes JPEG, se parecen a los archivos de Excel,

580
00:36:42,550 --> 00:36:46,400
y recuperarlas de esa manera, incluso si el equipo se ha olvidado de ellos allí.

581
00:36:46,400 --> 00:36:49,820
Así que la única manera de realmente eliminar los datos, como veremos en el futuro,

582
00:36:49,820 --> 00:36:54,190
es fregar o limpiar el archivo o disco duro -

583
00:36:54,190 --> 00:36:56,540
Realmente no se puede eliminar el 0 y 1

584
00:36:56,540 --> 00:36:59,440
porque de lo contrario empezaría con una unidad de disco duro gigabyte

585
00:36:59,440 --> 00:37:02,380
y que iba a terminar con un disco duro megabyte si constantemente se borrar,

586
00:37:02,380 --> 00:37:04,380
literalmente, 0s y 1s.

587
00:37:04,380 --> 00:37:06,310
Entonces, ¿qué haría usted si realmente quería cubrir sus pistas

588
00:37:06,310 --> 00:37:10,510
y el problema fundamental es que todavía hay 0s y 1s en el disco?

589
00:37:10,510 --> 00:37:14,930
Veo a alguien que físicamente gesticulando rompería el dispositivo. Eso va a funcionar.

590
00:37:14,930 --> 00:37:19,600
[Risas] Pero si eso es algo de una solución cara, lo que sería más razonable?

591
00:37:19,600 --> 00:37:23,270
Si. >> [Estudiante] Sobrescribir ellos. >> Sobreescribirlos con qué? >> [Estudiante] Otros datos.

592
00:37:23,270 --> 00:37:29,070
Otros datos. Usted puede sobrescribir el disco con 0s o 1s o 0s todos, todos 1s.

593
00:37:29,070 --> 00:37:31,230
>> Y eso es precisamente lo que algunos de los programas hace.

594
00:37:31,230 --> 00:37:33,570
Usted puede comprar el software o incluso conseguir el software libre,

595
00:37:33,570 --> 00:37:36,610
e incluso integrada en Mac OS en estos días, por lo menos en Windows,

596
00:37:36,610 --> 00:37:38,660
es la capacidad de borrar de forma segura.

597
00:37:38,660 --> 00:37:41,960
En realidad, si usted quiere todo jonrones hoy si tienes un Mac y hacer esto,

598
00:37:41,960 --> 00:37:45,740
si tienes algunas cosas en su bote de basura, puede hacerlo Secure Empty Trash,

599
00:37:45,740 --> 00:37:47,610
que hace exactamente eso.

600
00:37:47,610 --> 00:37:53,350
En lugar de borrar archivos sólo aquí, no borra el aquí 0s y 1s,

601
00:37:53,350 --> 00:38:01,240
más bien, sólo cambia todos ellos, por ejemplo, a 0s y punto, punto, punto.

602
00:38:01,240 --> 00:38:05,330
Así que uno de los conjuntos de procesadores futuros en realidad será recuperar intencionalmente datos -

603
00:38:05,330 --> 00:38:08,430
fotografías que hemos tomado de las personas, lugares y cosas en el campus

604
00:38:08,430 --> 00:38:12,810
para que vamos a hacer una imagen forense de la tarjeta de memoria de una cámara digital,

605
00:38:12,810 --> 00:38:17,120
que es la idea misma - y que tendrá que ser desafiados a encontrar realmente

606
00:38:17,120 --> 00:38:20,160
los patrones que representan imágenes JPEG en el disco duro,

607
00:38:20,160 --> 00:38:23,610
al igual que el ex estudiante cuyo correo electrónico que leí hace unas semanas hizo

608
00:38:23,610 --> 00:38:25,860
para recuperar fotografías de su hermana.

609
00:38:25,860 --> 00:38:30,300
¿Por qué no nos tomamos un descanso de 5 minutos aquí, y vamos a reagrupar con más memoria.

610
00:38:33,030 --> 00:38:38,610
Así que aquí es donde las cosas se ponen un poco alucinante, pero este es un paso muy potente

611
00:38:38,610 --> 00:38:40,480
hacia la comprensión de este aún más.

612
00:38:40,480 --> 00:38:42,900
Aquí hay un programa llamado pointers.c.

613
00:38:42,900 --> 00:38:45,430
Es uno de código de ejemplo de hoy.

614
00:38:45,430 --> 00:38:51,280
Note que en las primeras líneas, 19 a 22, todo lo que estamos haciendo es algo así como GetString

615
00:38:51,280 --> 00:38:54,460
y devolver una dirección, almacenándola en s.

616
00:38:54,460 --> 00:38:58,380
A partir de entonces para pset incluso 3 si quieres pero pset 4 y en

617
00:38:58,380 --> 00:39:01,030
donde usted puede comenzar a tomar estas ruedas de entrenamiento fuera de ti mismo,

618
00:39:01,030 --> 00:39:04,030
no hay ninguna razón para pretender que las cadenas de dejado de existir.

619
00:39:04,030 --> 00:39:07,030
Es ciertamente correcto empezar diciendo char *.

620
00:39:07,030 --> 00:39:12,610
>> Como acotación al margen, en referencias en línea y en los libros que a menudo puede ver la estrella junto a la variable.

621
00:39:12,610 --> 00:39:15,600
Usted podría incluso ver los espacios alrededor de los dos lados de la misma.

622
00:39:15,600 --> 00:39:17,680
Todos estos son funcionalmente correcto.

623
00:39:17,680 --> 00:39:21,180
Por ahora, sin embargo, vamos a estandarizar este método para hacer super claro

624
00:39:21,180 --> 00:39:24,000
char * que es como decir puntero a caracter.

625
00:39:24,000 --> 00:39:25,680
Ese es el tipo de datos.

626
00:39:25,680 --> 00:39:28,730
Y a continuación, el nombre de la variable s es en este caso.

627
00:39:28,730 --> 00:39:31,180
Para ello hemos conseguido una cuerda y lo hemos llamado s.

628
00:39:31,180 --> 00:39:35,180
Y entonces aquí cuenta de que estoy haciendo en realidad un poco de engaño.

629
00:39:35,180 --> 00:39:39,080
Esto se llama aritmética de punteros, que es una especie de súper simple.

630
00:39:39,080 --> 00:39:41,790
Sólo significa sumar y restar números a los punteros.

631
00:39:41,790 --> 00:39:43,660
Pero esto realmente funciona.

632
00:39:43,660 --> 00:39:49,170
Este programa aparentemente imprime la cadena s 1 carácter por línea de tal manera que el resultado final -

633
00:39:49,170 --> 00:39:54,920
Sólo así podemos echar a perder a dónde va esto, hacer sugerencias, ejecute punteros, déjame zoom in

634
00:39:54,920 --> 00:39:58,940
Ahora me deja escribir algo como HOLA y el tipo Intro

635
00:39:58,940 --> 00:40:01,080
e imprime un carácter por línea.

636
00:40:01,080 --> 00:40:04,730
Hasta hace un segundo, hubiéramos hecho esto con notación de corchetes.

637
00:40:04,730 --> 00:40:09,760
Tendríamos un bucle for y que haríamos printf de s [i] y nos gustaría hacer eso una y otra vez y otra vez

638
00:40:09,760 --> 00:40:11,950
con un n barra invertida al final de cada línea.

639
00:40:11,950 --> 00:40:16,800
Pero este programa es diferente. Este programa se utiliza, literalmente, la aritmética.

640
00:40:16,800 --> 00:40:18,860
Entonces, ¿qué está pasando aquí?

641
00:40:18,860 --> 00:40:24,720
En primer lugar, antes de que este lazo aún se ejecuta, lo que, para ser claros, es realmente s?

642
00:40:24,720 --> 00:40:27,270
S es? >> [Estudiante] Una dirección. >> Una dirección.

643
00:40:27,270 --> 00:40:32,980
>> Y es la dirección de, en el caso de hola, el primer carácter de la palabra, que es h.

644
00:40:32,980 --> 00:40:37,370
Así que s es, en este ejemplo particular, la dirección de h.

645
00:40:37,370 --> 00:40:41,850
Entonces, ¿qué significa eso para hacer s + i?

646
00:40:41,850 --> 00:40:46,280
Bueno, i comienza en 0 en este bucle for. Hemos hecho muchas veces.

647
00:40:46,280 --> 00:40:49,760
Me va a subir a la longitud de la cadena, al parecer.

648
00:40:49,760 --> 00:40:53,950
Así que en la primera iteración de este bucle, i es evidentemente 0.

649
00:40:53,950 --> 00:41:01,740
Así que esta expresión está diciendo s + i - más bien, s +0, eso es, obviamente, sólo s.

650
00:41:01,740 --> 00:41:04,320
Entonces, ¿qué es * s aquí?

651
00:41:04,320 --> 00:41:08,530
Ahora estamos utilizando la estrella de una manera ligeramente diferente.

652
00:41:08,530 --> 00:41:13,080
Déjame ir por delante y deshacerse de t porque hemos terminado hablando de t y copias de s.

653
00:41:13,080 --> 00:41:15,540
Ahora sólo quiero contar una historia que involucra s.

654
00:41:15,540 --> 00:41:20,090
Y así, en este momento, después de tipo string, nuestro mundo se ve absolutamente como lo hacía antes

655
00:41:20,090 --> 00:41:26,630
con sólo s almacenar la dirección de h y de manera más general que señala en la cadena hola.

656
00:41:26,630 --> 00:41:33,170
Si ahora hago una línea como * (s + i), vamos a probar esto.

657
00:41:33,170 --> 00:41:40,140
Así * (s + i). Permítanme simplificar esto porque esto es 0, por lo que este es * (s +0).

658
00:41:40,140 --> 00:41:43,790
Bueno, espera un minuto. Simplificar aún más. Esto es * (s).

659
00:41:43,790 --> 00:41:47,020
Bueno, ahora los paréntesis son una especie de estúpido, así que ahora vamos a hacer * s.

660
00:41:47,020 --> 00:41:50,540
Así, en la primera iteración de este bucle, que la línea que está resaltado, 26,

661
00:41:50,540 --> 00:41:53,650
es más o menos equivalente a la impresión de esto.

662
00:41:53,650 --> 00:41:56,040
¿Cuál es el tipo de datos * s?

663
00:41:56,040 --> 00:42:00,770
En este contexto, porque la estrella pasa a ser casi el mismo s,

664
00:42:00,770 --> 00:42:04,930
pero más específicamente, porque ya no estamos declarando s,

665
00:42:04,930 --> 00:42:09,730
no estamos creando una variable más, no hay ninguna mención de char * en la línea 26,

666
00:42:09,730 --> 00:42:14,280
no hay mención de la cadena de palabras clave, sólo estamos usando una variable llamada s,

667
00:42:14,280 --> 00:42:19,650
Resulta que ahora la estrella tiene un poco diferente y, sin duda, confundiendo el significado.

668
00:42:19,650 --> 00:42:26,590
* S aquí significa ir a la dirección de s e imprimir lo que está allí.

669
00:42:26,590 --> 00:42:33,750
Así que s está aquí, s * es - algo así como Serpientes y Escaleras, siga la flecha - aquí.

670
00:42:33,750 --> 00:42:35,850
Así que esto es * s.

671
00:42:35,850 --> 00:42:39,060
>> Así que lo que se imprime en la primera iteración de ese bucle en la línea 26?

672
00:42:39,060 --> 00:42:42,170
Puedo imprimir% c, que es el marcador de posición para un carácter,

673
00:42:42,170 --> 00:42:48,520
entonces un \ n para una nueva línea. * (S + i), donde i es 0 es precisamente esto.

674
00:42:48,520 --> 00:42:53,670
Entonces, ¿qué puedo hacer carbón en lugar de c%? H.

675
00:42:53,670 --> 00:42:56,900
En la siguiente iteración del bucle - es probable que pueda ver dónde va esto -

676
00:42:56,900 --> 00:43:01,350
la siguiente iteración i es obviamente 1, por lo que este medio s +1,

677
00:43:01,350 --> 00:43:05,580
y ahora me hace falta el paréntesis porque ahora la estrella tiene que decir

678
00:43:05,580 --> 00:43:08,620
ir a la dirección de memoria s +1.

679
00:43:08,620 --> 00:43:14,170
¿Cuál es s? Vamos a retroceder en el tiempo y decir esto ahora arrow realidad no se nos está haciendo ningún favor.

680
00:43:14,170 --> 00:43:18,450
Que es más específicamente decir que este es el almacenamiento de la serie 123

681
00:43:18,450 --> 00:43:25,110
ya que el inicio de esta cadena hola, esta es la dirección 123, esto es 124, y así sucesivamente.

682
00:43:25,110 --> 00:43:30,550
Así que en la segunda iteración cuando digo s +1, que es como decir que un 123,

683
00:43:30,550 --> 00:43:35,340
también conocido como 124, así que lo que se imprime caracteres en la segunda iteración?

684
00:43:35,340 --> 00:43:37,850
E en dirección de memoria 124.

685
00:43:37,850 --> 00:43:44,440
Entonces + más, 125, 126, 127, y por suerte este bucle se detiene antes de llegar aquí

686
00:43:44,440 --> 00:43:49,040
porque estoy usando strlen para asegurarse de que no cuenta demasiado alto.

687
00:43:49,040 --> 00:43:50,810
De modo que también lo es.

688
00:43:50,810 --> 00:43:55,000
De nuevo, esto es como si hubiéramos hecho hace una semana.

689
00:43:55,000 --> 00:43:59,200
Deja que lo escriba en la línea de abajo a pesar de que no queremos hacer ambas cosas.

690
00:43:59,200 --> 00:44:02,500
Esto es idéntico a este ahora.

691
00:44:02,500 --> 00:44:08,310
>> Así que, aunque s es una cadena, como lo hemos estado llamando durante semanas, s es realmente un char *.

692
00:44:08,310 --> 00:44:13,270
Así que si queremos ser súper anal, es muy adecuado para escribir el carácter específico

693
00:44:13,270 --> 00:44:17,490
en la posición i-ésima usando estas direcciones numéricas y de este operador estrella,

694
00:44:17,490 --> 00:44:20,470
pero, francamente, esto es simplemente mucho más limpio. Así que esto no es malo.

695
00:44:20,470 --> 00:44:26,720
No hay razón para dejar de hacer la línea 27 aquí, pero el 26 es funcionalmente el mismo,

696
00:44:26,720 --> 00:44:31,570
y es funcionalmente lo mismo exactamente por las razones que hemos estado discutiendo hasta ahora.

697
00:44:31,570 --> 00:44:33,650
Y por último, 29 es sólo una buena práctica.

698
00:44:33,650 --> 00:44:38,420
Llamar gratis de s significa que ahora usted está dando de nuevo la memoria que le dio GetString

699
00:44:38,420 --> 00:44:41,630
porque, de nuevo, como he mencionado lunes, GetString por semana

700
00:44:41,630 --> 00:44:44,180
ha sido la introducción de un bug en el código.

701
00:44:44,180 --> 00:44:46,490
Su código de semana ha tenido pérdidas de memoria

702
00:44:46,490 --> 00:44:49,970
por el que usted ha estado preguntando GetString para la memoria, pero nunca he estado dando vuelta.

703
00:44:49,970 --> 00:44:53,410
Y eso fue elegido deliberadamente por nosotros pedagógicamente

704
00:44:53,410 --> 00:44:55,880
porque es simplemente demasiado como para pensar en el principio.

705
00:44:55,880 --> 00:44:57,710
Pero ahora necesitamos más simetría.

706
00:44:57,710 --> 00:45:00,830
Si le pide al equipo para la memoria, como es el caso de GetString,

707
00:45:00,830 --> 00:45:02,820
como es el caso aparentemente para malloc,

708
00:45:02,820 --> 00:45:07,970
Ahora debe de pset 4 en adelante también liberar la memoria tal.

709
00:45:07,970 --> 00:45:11,650
Tenga en cuenta que esto es diferente de decir n int.

710
00:45:11,650 --> 00:45:15,040
No es necesario para liberar a esto porque usted no llamó a GetString

711
00:45:15,040 --> 00:45:16,890
y usted no llamó a malloc.

712
00:45:16,890 --> 00:45:20,610
>> E incluso si usted llama getInt ya que finalmente va a ver,

713
00:45:20,610 --> 00:45:25,520
GetInt no asigna memoria para usted, porque en realidad se puede pasar alrededor de los números enteros

714
00:45:25,520 --> 00:45:29,430
y flota y caracteres exactamente de la manera que hemos estado haciendo durante semanas.

715
00:45:29,430 --> 00:45:33,960
Cuerdas, sin embargo, son especiales porque en realidad son la concatenación de caracteres múltiples.

716
00:45:33,960 --> 00:45:37,450
Así que son sólo diferentes de caracteres y carrozas y enteros y similares.

717
00:45:37,450 --> 00:45:39,980
Pero vamos a volver a eso en poco tiempo.

718
00:45:39,980 --> 00:45:44,920
Cualquier pregunta luego en este inicio de punteros? Si.

719
00:45:44,920 --> 00:45:49,690
[Pregunta estudiante inaudible]

720
00:45:49,690 --> 00:45:51,440
Ah, muy buena pregunta.

721
00:45:51,440 --> 00:45:55,790
Una de las pocas cosas en realidad C hace por ti, lo que es conveniente,

722
00:45:55,790 --> 00:46:00,110
se da cuenta de que para ti lo que el tamaño es del tipo de datos

723
00:46:00,110 --> 00:46:03,060
y luego hace ese tipo de multiplicación para usted.

724
00:46:03,060 --> 00:46:06,610
Esto es irrelevante en el caso de los caracteres, ya que casi siempre es un char es un byte,

725
00:46:06,610 --> 00:46:08,150
así que esto funciona.

726
00:46:08,150 --> 00:46:11,220
Pero por el bien de la discusión, si en realidad estaban imprimiendo los números enteros

727
00:46:11,220 --> 00:46:15,500
y que estaba tratando de imprimir un poco de s valor que se apunta a un número entero,

728
00:46:15,500 --> 00:46:20,720
Del mismo modo que no tendría que hacer + 4 * i sólo porque un int es de 4 bytes.

729
00:46:20,720 --> 00:46:25,780
La aritmética de punteros significa que C y el compilador hacer todo lo que cálculos por usted.

730
00:46:25,780 --> 00:46:29,190
Todo lo que tienes que tener en cuenta es la cuenta en una especie de sentido humano. Si.

731
00:46:29,190 --> 00:46:35,200
[Estudiante] Si se declara una cadena dentro de un bucle for, tienes que liberarlo más tarde?

732
00:46:35,200 --> 00:46:36,760
Buena pregunta.

733
00:46:36,760 --> 00:46:41,390
>> Si se declara una cadena dentro del bucle for, ¿es necesario para liberarlo más tarde?

734
00:46:41,390 --> 00:46:47,520
Sólo es necesario para liberar la memoria que se puede asignar a GetString o con malloc.

735
00:46:47,520 --> 00:46:53,110
Así que si usted acaba de decir algo como - déjame poner llaves ahora lo que todo el código está relacionado.

736
00:46:53,110 --> 00:46:58,580
Si hizo algo, aunque buggily, como este, char * t = s,

737
00:46:58,580 --> 00:47:03,450
usted no necesita t t libres porque no incluía ninguna mención de malloc o GetString.

738
00:47:03,450 --> 00:47:08,960
Si por el contrario te hizo esto, GetString, entonces sí, usted tendría que t libres.

739
00:47:08,960 --> 00:47:14,350
Y de hecho, la única oportunidad de hacerlo es ahora dentro de este bucle, para la misma edición de alcance

740
00:47:14,350 --> 00:47:16,060
que hemos discutido en el pasado.

741
00:47:16,060 --> 00:47:18,830
De lo contrario, estaría la asignación de memoria, asignación de memoria, asignación de memoria,

742
00:47:18,830 --> 00:47:21,230
y al final del programa, porque estás fuera de ese circuito,

743
00:47:21,230 --> 00:47:24,240
t no existe, pero nunca se dijo que el sistema operativo

744
00:47:24,240 --> 00:47:26,750
que no era necesario que la memoria más.

745
00:47:26,750 --> 00:47:30,430
Y en poco tiempo, por pset 4 o 5 te equipará con un programa llamado Valgrind,

746
00:47:30,430 --> 00:47:34,160
que es similar en espíritu al BGF ya que tiene algo así como una interfaz arcano,

747
00:47:34,160 --> 00:47:35,750
pero su propósito en la vida es ayudar.

748
00:47:35,750 --> 00:47:39,380
Y Valgrind es un programa que en el futuro busque sus programas

749
00:47:39,380 --> 00:47:42,550
en busca de fugas de memoria, ya sea por GetString o malloc,

750
00:47:42,550 --> 00:47:47,800
que vamos a empezar a utilizar con mayor razón ahora que deje de usar la biblioteca CS50 tanto.

751
00:47:47,800 --> 00:47:53,030
Por fin ahora tenemos una especie de vocabulario y el tipo de modelo mental en la teoría

752
00:47:53,030 --> 00:47:55,170
con los que resolver este programa rota.

753
00:47:55,170 --> 00:47:59,410
>> Así que en este programa rota, swap trabaja dentro de swap,

754
00:47:59,410 --> 00:48:05,280
pero en realidad nunca funcionó en la principal causa principal pasaba en x e y, recordemos,

755
00:48:05,280 --> 00:48:07,260
y los que fueron pasados ​​por en valores, por así decirlo.

756
00:48:07,260 --> 00:48:09,330
Las copias de ellos fueron dados a cambiar.

757
00:48:09,330 --> 00:48:12,520
Al final del intercambio, a y b se había hecho intercambiado,

758
00:48:12,520 --> 00:48:16,120
pero, por supuesto, x e y, como vimos el lunes, no lo había sido.

759
00:48:16,120 --> 00:48:19,940
Así que propongo en verde aquí que esta es realmente la solución aquí.

760
00:48:19,940 --> 00:48:22,640
Y, de hecho, vamos a mover mis estrellas para estar en consonancia

761
00:48:22,640 --> 00:48:24,440
aunque, de nuevo, funcionalmente esto no importa.

762
00:48:24,440 --> 00:48:28,730
En las próximas semanas vamos a explicar cuándo y por qué es importante.

763
00:48:28,730 --> 00:48:30,600
Así, en verde ahora es una solución.

764
00:48:30,600 --> 00:48:33,700
Francamente, parece mucho más desordenado porque tengo todas estas estrellas.

765
00:48:33,700 --> 00:48:35,380
Permítanme señalar una cosa.

766
00:48:35,380 --> 00:48:40,040
La línea superior aquí donde dice int * a * b e int

767
00:48:40,040 --> 00:48:42,820
fundamentalmente haciendo lo mismo que siempre ha hecho.

768
00:48:42,820 --> 00:48:47,070
Se declara dos argumentos o parámetros a cambiar,

769
00:48:47,070 --> 00:48:49,940
el primero de los cuales es un puntero int llamada,

770
00:48:49,940 --> 00:48:53,100
el segundo de los cuales es un puntero int llamado b.

771
00:48:53,100 --> 00:48:55,770
Lo único que hay de nuevo en este punto es el hecho de que hay una estrella allí.

772
00:48:55,770 --> 00:48:59,340
>> ¿Qué significa eso? A no es un int, b no es un int.

773
00:48:59,340 --> 00:49:04,100
Una es la dirección de un entero y b es la dirección de un int diferente.

774
00:49:04,100 --> 00:49:06,980
Aquí abajo, aquí es donde admito C vuelve confuso.

775
00:49:06,980 --> 00:49:09,790
Ahora estamos utilizando una estrella, pero tiene un significado diferente en este contexto.

776
00:49:09,790 --> 00:49:13,150
Porque no estamos declarando punteros como estamos aquí,

777
00:49:13,150 --> 00:49:15,500
aquí estamos dereferencing cosas.

778
00:49:15,500 --> 00:49:21,520
Así que, técnicamente, la estrella en este contexto de la primera línea, segunda y tercera dentro de swap

779
00:49:21,520 --> 00:49:24,560
es el operador de indirección, lo cual significa ir allí.

780
00:49:24,560 --> 00:49:27,400
Así que como mi dedo seguía la flecha en h,

781
00:49:27,400 --> 00:49:31,100
* A los medios ir a esa dirección y me hallaréis, el int que está ahí.

782
00:49:31,100 --> 00:49:34,250
* B medios ir a la dirección y me pasa lo que hay.

783
00:49:34,250 --> 00:49:40,730
Así que vamos a volver a dibujar la imagen de lunes ahora usando una pila de marcos,

784
00:49:40,730 --> 00:49:43,130
el fondo de la cual va a ser principal,

785
00:49:43,130 --> 00:49:47,600
el superior de los cuales va a ser swap,

786
00:49:47,600 --> 00:49:50,880
para que nuestro mundo se ve, al igual que lunes, así.

787
00:49:50,880 --> 00:49:53,620
He aquí un trozo de memoria que principal se va a utilizar.

788
00:49:53,620 --> 00:49:56,520
>> Recuerde del lunes que el programa sólo tenía 2 variables,

789
00:49:56,520 --> 00:50:01,930
uno llamado X y un llamado y, y yo había puesto los números 1 y 2 hay.

790
00:50:01,930 --> 00:50:06,580
Ahora, cuando yo llamo cambiar como lo hice el lunes,

791
00:50:06,580 --> 00:50:11,000
anteriormente cuando he utilizado la versión roja de este programa, que tiene este aspecto,

792
00:50:11,000 --> 00:50:17,470
Tengo dos parámetros, a y b, y lo que escribimos aquí y aquí?

793
00:50:17,470 --> 00:50:21,160
Sólo 1 y 2, literalmente copias de x e y.

794
00:50:21,160 --> 00:50:23,070
Hoy podemos cambiar eso.

795
00:50:23,070 --> 00:50:28,510
Hoy en vez de pasar en enteros a y b que vamos a pasar en dos direcciones.

796
00:50:28,510 --> 00:50:34,290
Las direcciones de suceder para que apunte a ints, pero esas direcciones no son ellos mismos intercepciones.

797
00:50:34,290 --> 00:50:37,330
Son direcciones. Es como una dirección postal.

798
00:50:37,330 --> 00:50:40,580
Así que ahora tenemos que acaba de darme un poco más detalle en la pantalla.

799
00:50:40,580 --> 00:50:43,250
Esta es la memoria de mi computadora, ya que ha estado todo el día.

800
00:50:43,250 --> 00:50:45,120
Ahora necesitamos algo de arbitrario esquema de numeración.

801
00:50:45,120 --> 00:50:50,580
Así que vamos a decir, por casualidad, que esta es la dirección de memoria de 123, 124.

802
00:50:50,580 --> 00:50:55,660
Digamos que este es de 125, esto es 126, y así sucesivamente, pero eso es totalmente arbitraria.

803
00:50:55,660 --> 00:50:58,590
Sólo necesitamos un esquema de numeración en mi memoria.

804
00:50:58,590 --> 00:51:04,030
Así que ahora cuando realmente pasa en x e y, no voy a pasar en X e Y;

805
00:51:04,030 --> 00:51:08,400
Voy a pasar en la dirección postal, por así decirlo, de x y de y

806
00:51:08,400 --> 00:51:11,870
de modo que lo que se almacena aquí y aquí no es 1 y 2,

807
00:51:11,870 --> 00:51:16,030
pero si puedes ver mi pequeño texto, lo que se pasa por aquí y aquí?

808
00:51:16,030 --> 00:51:23,340
[Respuesta de los estudiantes inaudible] >> Exactamente. 123 se puso aquí y 124 se puso aquí.

809
00:51:23,340 --> 00:51:28,910
>> Ahora, porque yo la estrella de esta forma primera línea aquí en la parte superior,

810
00:51:28,910 --> 00:51:34,340
mi programa sólo sabe que 123 y 124, aunque son obviamente enteros

811
00:51:34,340 --> 00:51:40,160
que cualquier humano podría notar, ellos deben ser interpretados como direcciones, direcciones numéricas.

812
00:51:40,160 --> 00:51:43,250
No son en sí mismos enteros, que son las direcciones,

813
00:51:43,250 --> 00:51:46,120
y eso es porque me he puesto explícitamente las estrellas allí.

814
00:51:46,120 --> 00:51:51,360
Así que ahora en mi línea de primera, segunda y tercera de código real lo que sucede aquí?

815
00:51:51,360 --> 00:51:53,380
Vamos a dibujar el resto de la imagen.

816
00:51:53,380 --> 00:51:56,980
Tmp es igual que lo fue el lunes. Nada especial en tmp.

817
00:51:56,980 --> 00:52:03,060
Está a sólo unos locales de 32 bits variable, y dentro de ese parecer estoy almacenando el valor de * a.

818
00:52:03,060 --> 00:52:08,580
Ahora, si me acaba de decir tmp = a, lo que me puso aquí? >> [Estudiante] 123.

819
00:52:08,580 --> 00:52:10,370
123. Pero eso no es lo que estoy haciendo.

820
00:52:10,370 --> 00:52:13,670
Estoy diciendo tmp = * a. Significa estrella ir allí.

821
00:52:13,670 --> 00:52:19,370
Así que aquí está una, 123. ¿Cómo puedo ir? Imagina como si hubiera una flecha.

822
00:52:19,370 --> 00:52:24,460
Bueno, ahí está, 1. Así que lo que se almacena en tmp, al parecer? A sólo 1.

823
00:52:24,460 --> 00:52:29,620
En otras palabras, tmp es * a *, un medio de ir a la dirección que se encuentra actualmente en una,

824
00:52:29,620 --> 00:52:31,320
que aparentemente es 123.

825
00:52:31,320 --> 00:52:33,910
>> Bueno, aquí estamos en la posición 123, veo el número 1,

826
00:52:33,910 --> 00:52:35,670
así que me voy a poner el número 1 allí.

827
00:52:35,670 --> 00:52:39,020
Ahora, ¿qué es lo que hago en la línea 2, * a * = b?

828
00:52:39,020 --> 00:52:44,570
Este es un poco más complicado porque ahora lo que es un? Es 123.

829
00:52:44,570 --> 00:52:50,220
Así que * a es ¿dónde? Justo donde estaba antes. Así que ir allí. Bien.

830
00:52:50,220 --> 00:52:53,420
Ahora, por último, y, finalmente, se empezará a tener sentido, es de esperar,

831
00:52:53,420 --> 00:53:00,280
* B significa que lo que está en b? 124. Así que tengo que ir allí, que es 2.

832
00:53:00,280 --> 00:53:03,430
Entonces, ¿qué me pongo a dónde?

833
00:53:03,430 --> 00:53:10,100
2 entra aquí porque va a * b * a. Así que voy a hacer eso.

834
00:53:10,100 --> 00:53:13,120
Y ya se puede ver, tal vez, que estamos mucho más cerca

835
00:53:13,120 --> 00:53:17,710
a la solución de este problema estúpido, simple correctamente por primera vez

836
00:53:17,710 --> 00:53:20,920
porque ahora todavía nos queda un recuerdo de lo que era x,

837
00:53:20,920 --> 00:53:23,230
tenemos 2 copias, sin duda, de y,

838
00:53:23,230 --> 00:53:25,850
pero ahora dice que la línea 3 * b.

839
00:53:25,850 --> 00:53:31,080
Así que aquí está b. B * significa ir allí. Entonces, ¿dónde es la ubicación 124?

840
00:53:31,080 --> 00:53:35,560
Es al parecer aquí. Entonces, ¿qué pongo aquí? Obviamente, tmp.

841
00:53:35,560 --> 00:53:39,600
Así que ahora hago esto. Así que tengo una aquí y 2 aquí.

842
00:53:39,600 --> 00:53:43,560
Y ahora, ¿qué pasa con todo esto, el 123, el 124, y el 1?

843
00:53:43,560 --> 00:53:47,910
Tan pronto como retornos de swap, esta memoria es tan buena como perdido

844
00:53:47,910 --> 00:53:51,070
porque tan pronto como retornos de intercambio, el sistema operativo

845
00:53:51,070 --> 00:53:54,190
es libre de utilizar la memoria de nuevo en el futuro.

846
00:53:54,190 --> 00:53:58,870
Sólo la memoria principal en la parte inferior de esta pila de llamada se pega alrededor.

847
00:53:58,870 --> 00:54:01,470
>> Y así, por fin tenemos ahora una versión de trabajo.

848
00:54:01,470 --> 00:54:06,310
Déjame entrar en swap.c y observe lo siguiente.

849
00:54:06,310 --> 00:54:11,280
En la parte superior del programa que he cambiado mi prototipo para ser int * a * b e int.

850
00:54:11,280 --> 00:54:15,000
Así que lo único que cambié para ir de rojo, que era malo, al verde, lo cual es bueno,

851
00:54:15,000 --> 00:54:17,350
se le añadí estas estrellas de hoy.

852
00:54:17,350 --> 00:54:21,520
Pero aquí abajo, en sí mismo cambiar tuve que copiar, pegar lo que era justo en la diapositiva.

853
00:54:21,520 --> 00:54:24,140
Tengo aquí una estrella, la estrella aquí - que coincide con el prototipo -

854
00:54:24,140 --> 00:54:27,930
y entonces todas estas cosas ahora tienen estrellas excepto tmp

855
00:54:27,930 --> 00:54:30,680
porque el uso de una variable temporal, no hay nada nuevo allí.

856
00:54:30,680 --> 00:54:33,040
Sólo necesito de almacenamiento temporal para un int.

857
00:54:33,040 --> 00:54:34,820
Así que no necesitamos una estrella allí.

858
00:54:34,820 --> 00:54:39,310
Sólo necesitamos la estrella para que podamos atravesar este tipo de límite arbitrario

859
00:54:39,310 --> 00:54:42,900
entre estos dos marcos en la memoria de mi ordenador.

860
00:54:42,900 --> 00:54:45,630
Pero una última cosa tiene que cambiar, y que podría haber vislumbrado ya.

861
00:54:45,630 --> 00:54:48,810
¿Qué otra línea es obviamente diferente ahora? >> [Los estudiantes] y x.

862
00:54:48,810 --> 00:54:53,270
>> Sí, así que 25 es la última línea de código que necesita cambiar para que esto funcione.

863
00:54:53,270 --> 00:54:58,360
Hace una semana y hasta el lunes de la línea 25 se veía así, intercambie x e y,

864
00:54:58,360 --> 00:55:02,020
y esta se rompió porque si dices swap (x, y)

865
00:55:02,020 --> 00:55:05,660
le está dando copias de x e y para intercambiar, entonces está haciendo lo suyo,

866
00:55:05,660 --> 00:55:09,080
pero nunca en realidad está cambiando xey sí mismo.

867
00:55:09,080 --> 00:55:12,880
Así que incluso si usted nunca ha visto antes a este personaje con el símbolo de unión en el código,

868
00:55:12,880 --> 00:55:15,860
acaba de tomar una conjetura. ¿Qué significa el símbolo de unión hacen, al parecer?

869
00:55:15,860 --> 00:55:17,890
[Estudiante] Tome la dirección. >> Toma la dirección.

870
00:55:17,890 --> 00:55:21,160
De modo que el signo está diciendo dame la dirección de x.

871
00:55:21,160 --> 00:55:25,590
¿Quién sabe dónde está? Le pasa a ser 123. No me importa. Sólo dame la dirección de x.

872
00:55:25,590 --> 00:55:28,340
& Y significa dame la dirección de y.

873
00:55:28,340 --> 00:55:34,450
Y en ese punto la historia es perfectamente coherente con la imagen que dibujó hace un momento.

874
00:55:34,450 --> 00:55:38,310
>> Así que voy a admitir punteros, sin duda para mí cuando empecé a aprender esto,

875
00:55:38,310 --> 00:55:40,570
fueron sin duda una de las cosas más difíciles de envolver mi cabeza alrededor.

876
00:55:40,570 --> 00:55:43,760
Pero dese cuenta, sobre todo porque seguimos jugando con este tipo de cosas,

877
00:55:43,760 --> 00:55:48,030
si lo desglosamos a esta clase de súper simple intelectualmente interesantes problemas

878
00:55:48,030 --> 00:55:52,270
de mover sólo los números más, la respuesta a una gran confusión con los punteros

879
00:55:52,270 --> 00:55:56,590
realmente se pueden derivar de estas mecánicas muy básicas.

880
00:55:56,590 --> 00:55:59,070
Aquí está la dirección. Ve allí con la estrella.

881
00:55:59,070 --> 00:56:03,830
O a la inversa, esto es un símbolo de unión. Averiguar cuál es la dirección que realmente es.

882
00:56:03,830 --> 00:56:06,270
Está bien.

883
00:56:06,270 --> 00:56:09,000
Entonces, ¿dónde está toda esta memoria viene?

884
00:56:09,000 --> 00:56:12,360
Hemos elaborado esta imagen un par de veces, y me siguen prometiendo que vamos a volver a ella,

885
00:56:12,360 --> 00:56:14,920
pero aquí es la representación de la memoria del equipo

886
00:56:14,920 --> 00:56:17,420
que es un poco más marcado que nuestro pizarrón aquí está.

887
00:56:17,420 --> 00:56:21,590
El segmento de texto en la parte superior representa lo que respecta a su programa?

888
00:56:21,590 --> 00:56:26,090
[Respuesta de los estudiantes inaudible] >> ¿Cómo? Dilo de nuevo.

889
00:56:26,090 --> 00:56:28,660
[Estudiante] El programa actual. >> El programa en sí.

890
00:56:28,660 --> 00:56:32,430
>> Así que el Clang 0 y 1 que ha compilado después de escribir código C y que luego

891
00:56:32,430 --> 00:56:35,910
y la generación de extremos 0s y 1s hasta quedar escondido allí en la memoria

892
00:56:35,910 --> 00:56:38,570
porque cuando se hace doble clic en un icono en tu Mac o PC

893
00:56:38,570 --> 00:56:43,010
o ejecutar un comando como mario en su sistema, su 0s y 1s de disco

894
00:56:43,010 --> 00:56:45,700
se cargan en la memoria para que el ordenador pueda manipular

895
00:56:45,700 --> 00:56:47,540
y ejecutarlas con mayor rapidez.

896
00:56:47,540 --> 00:56:50,880
Así datos inicializados y datos sin inicializar, no vamos a hablar mucho de ellos,

897
00:56:50,880 --> 00:56:52,420
pero eso son sólo las variables globales.

898
00:56:52,420 --> 00:56:54,710
Inicializar las variables globales significa que usted dio a valores;

899
00:56:54,710 --> 00:56:59,300
sin inicializar variables globales significa que usted todavía no dan valores a.

900
00:56:59,300 --> 00:57:01,900
Entonces hay estas variables de entorno que estoy totalmente de onda va la mano menos,

901
00:57:01,900 --> 00:57:04,860
pero están ahí y que almacena cosas como su nombre de usuario

902
00:57:04,860 --> 00:57:08,090
y otro tipo de información de nivel inferior.

903
00:57:08,090 --> 00:57:12,880
Pero los más jugosos trozos de la disposición de su memoria es esa cosa llamada la pila y el heap.

904
00:57:12,880 --> 00:57:17,470
La pila de nuevo, para que quede claro, es la memoria que se utiliza cada vez que se llama a funciones,

905
00:57:17,470 --> 00:57:19,710
siempre que hay variables locales

906
00:57:19,710 --> 00:57:22,120
y siempre que haya parámetros que se pasan alrededor.

907
00:57:22,120 --> 00:57:24,490
Todo esto ocurre en la pila.

908
00:57:24,490 --> 00:57:29,570
El montón no hemos hablado, pero tomar una conjetura que usa la pila.

909
00:57:31,120 --> 00:57:32,690
Sólo una parte diferente de la memoria.

910
00:57:32,690 --> 00:57:36,620
Le pasa a ser dibujado aquí en la parte superior, pero eso es una convención pictórica arbitraria.

911
00:57:36,620 --> 00:57:41,670
¿Quién está al parecer se utiliza la memoria del montón por semanas?

912
00:57:41,670 --> 00:57:44,830
Es técnicamente pero indirectamente. >> [Estudiante] GetString.

913
00:57:44,830 --> 00:57:47,950
GetString y malloc. Así que aquí está la diferencia fundamental.

914
00:57:47,950 --> 00:57:51,300
>> ¿Sabes para las últimas semanas de que si necesitas memoria, sólo declarar una variable.

915
00:57:51,300 --> 00:57:54,560
Si usted necesita mucha memoria, declarar una matriz de derecho dentro de su función.

916
00:57:54,560 --> 00:57:59,620
Pero el problema que hemos mantenido enfrentamos es si declara las variables locales dentro de funciones,

917
00:57:59,620 --> 00:58:05,340
tan pronto como la función retorna, lo que ocurre con la memoria y las variables de esos?

918
00:58:05,340 --> 00:58:09,620
Sólo especie de que ya no es tuyo, ¿no? Simplemente desaparece una especie de vista conceptual.

919
00:58:09,620 --> 00:58:13,950
Sigue siendo físicamente allí, obviamente, pero ya no es su derecho de uso.

920
00:58:13,950 --> 00:58:17,160
Esto es obviamente problemático si quieres escribir funciones en la vida

921
00:58:17,160 --> 00:58:20,440
que en realidad asignar memoria y no devolverlo inmediatamente.

922
00:58:20,440 --> 00:58:24,180
Caso en cuestión: GetString propósito en la vida es no tener idea de antemano

923
00:58:24,180 --> 00:58:26,390
lo grande de una cadena que voy a escribir en el teclado,

924
00:58:26,390 --> 00:58:30,390
sino que tiene que ser capaz de asignar memoria para contener David o hola

925
00:58:30,390 --> 00:58:32,860
o un ensayo entero de que el usuario podría haber escrito pulg

926
00:58:32,860 --> 00:58:35,280
Así GetString ha estado usando malloc.

927
00:58:35,280 --> 00:58:38,910
Malloc por lo tanto no debe utilizar la pila;

928
00:58:38,910 --> 00:58:40,770
sino que está usando esta cosa llamada el montón.

929
00:58:40,770 --> 00:58:44,430
No hay nada diferente en la memoria. No es más rápido o más lento o algo por el estilo.

930
00:58:44,430 --> 00:58:46,570
Es sólo físicamente en un lugar diferente.

931
00:58:46,570 --> 00:58:50,120
>> Pero la regla es que la memoria que está asignada en el montón

932
00:58:50,120 --> 00:58:56,180
Nunca será quitado de vosotros, hasta que se llama - tomar una conjetura - libre.

933
00:58:56,180 --> 00:59:00,510
Por el contrario, cualquier memoria que pedir en la pila con sólo declarar una matriz

934
00:59:00,510 --> 00:59:03,320
o declarar una variable como la que hemos estado haciendo durante semanas,

935
00:59:03,320 --> 00:59:05,640
que, por defecto termina en la pila.

936
00:59:05,640 --> 00:59:09,550
Y que funciona muy bien 90% del tiempo, pero en esas ocasiones más raras

937
00:59:09,550 --> 00:59:12,470
en la que desea asignar la memoria y mantener a su alrededor,

938
00:59:12,470 --> 00:59:14,730
entonces usted necesita utilizar una función como malloc.

939
00:59:14,730 --> 00:59:19,370
O hemos utilizado una función como GetString, que a su vez utiliza malloc.

940
00:59:19,370 --> 00:59:23,300
Vamos a ver dónde podría romper hacia abajo y luego echar un vistazo a Binky.

941
00:59:23,300 --> 00:59:25,820
Volveremos a que en el futuro.

942
00:59:25,820 --> 00:59:29,270
Aquí hay un programa super sencillo que en las primeras 2 líneas hace qué?

943
00:59:29,270 --> 00:59:33,460
En Inglés, ¿qué estas primeras 2 líneas de código realizan dentro de la principal?

944
00:59:33,460 --> 00:59:35,600
[Respuesta de los estudiantes inaudible]

945
00:59:35,600 --> 00:59:37,880
Con cuidado. No me da la dirección de x o y.

946
00:59:37,880 --> 00:59:41,840
[Estudiante] Proporciona punteros a enteros. Bueno >>. Dame 2 punteros a enteros.

947
00:59:41,840 --> 00:59:45,130
En otras palabras, me dan 2 trozos de memoria que guardo dibujo hoy,

948
00:59:45,130 --> 00:59:46,950
a pesar de que lo ha borrado ahora, como cuadrados.

949
00:59:46,950 --> 00:59:50,000
Dame dos trozos de memoria, una llamada x, que se llama y -

950
00:59:50,000 --> 00:59:54,320
antes me llamaban s y t - y cuál es el tipo de ese trozo de memoria?

951
00:59:54,320 --> 00:59:57,160
Se va a almacenar una dirección.

952
00:59:57,160 --> 00:59:59,110
* Es de tipo int.

953
00:59:59,110 --> 01:00:01,630
>> Así que la dirección de un int con el tiempo va a vivir en x,

954
01:00:01,630 --> 01:00:03,860
la dirección de un int con el tiempo va a vivir en y,

955
01:00:03,860 --> 01:00:08,460
pero en un principio, lo que hay dentro de x e y? ¿Quién sabe? Valores de basura.

956
01:00:08,460 --> 01:00:10,180
No tiene nada que ver con punteros.

957
01:00:10,180 --> 01:00:12,720
Si no hemos puesto algo allí, ¿quién sabe lo que está realmente allí?

958
01:00:12,720 --> 01:00:18,950
Ahora, x. ¿Qué sucede aquí? Esto es de fiar porque ahora x es un puntero. Es un * int.

959
01:00:18,950 --> 01:00:21,870
Así que eso significa que puedo poner en la dirección x de algún trozo de memoria.

960
01:00:21,870 --> 01:00:25,120
¿Qué malloc volver? Perfecto, devuelve las direcciones,

961
01:00:25,120 --> 01:00:28,510
la dirección del primer byte de un pedazo entero de memoria.

962
01:00:28,510 --> 01:00:31,140
¿Cuántos bytes se esta asignando al parecer, por ejemplo, en el aparato?

963
01:00:31,140 --> 01:00:33,510
¿Cuál es el tamaño de un int? 4.

964
01:00:33,510 --> 01:00:36,600
Si piensas en la semana 1, no es super importante recordar siempre que,

965
01:00:36,600 --> 01:00:38,870
pero en este caso, es útil saber, 4 bytes.

966
01:00:38,870 --> 01:00:41,770
Así que esta es la asignación en el montón de 4 bytes

967
01:00:41,770 --> 01:00:46,110
y se devuelve la dirección de la primera que me arbitrariamente.

968
01:00:46,110 --> 01:00:47,700
Ahora, ¿qué está haciendo x?

969
01:00:47,700 --> 01:00:52,200
A * x = 42 está haciendo qué?

970
01:00:52,200 --> 01:00:57,150
Si en este punto de la historia que tenemos x, que tiene este aspecto con un valor basura,

971
01:00:57,150 --> 01:01:04,120
esto es ahora y con un valor basura, ahora en la línea 3 que he asignado 4 bytes.

972
01:01:04,120 --> 01:01:06,950
Este cuadro esencialmente se parece a esto.

973
01:01:06,950 --> 01:01:12,010
O más específicamente, si esta es la dirección arbitraria 123, esto es lo que nuestra historia ahora parece.

974
01:01:12,010 --> 01:01:23,940
* X = 42 ahora ¿qué significa? Eso significa ir a la dirección 123 y poner el número 42 allí.

975
01:01:23,940 --> 01:01:26,220
No es necesario dibujar estas líneas porque no estamos haciendo cadenas.

976
01:01:26,220 --> 01:01:29,480
>> Debería haber escrito así, y sólo por causa de la manifestación,

977
01:01:29,480 --> 01:01:33,240
42 como un tipo int ocupa mucho espacio, 4 bytes.

978
01:01:33,240 --> 01:01:35,960
Así que eso es lo que ha pasado allí, pero hay un problema ahora.

979
01:01:35,960 --> 01:01:40,580
* Y = 13. ¿Qué va a pasar aquí?

980
01:01:40,580 --> 01:01:46,470
El problema es y * en nuestro mundo simplificado sólo significa ir a la dirección en y.

981
01:01:46,470 --> 01:01:48,590
¿Qué hay en y? Es cierto valor basura.

982
01:01:48,590 --> 01:01:53,150
Así que vamos a suponer que ese valor es 5551212 basura, algo de loco.

983
01:01:53,150 --> 01:01:56,750
* Significa que Y van a abordar 5551212.

984
01:01:56,750 --> 01:02:00,450
Esto es así por aquí. No existe, por ejemplo.

985
01:02:00,450 --> 01:02:05,310
Así obtiene 13 * y medio que estoy tratando de dibujar 13 aquí. No existe.

986
01:02:05,310 --> 01:02:08,790
He superado el segmento de la pizarra. ¿Qué obtengo?

987
01:02:08,790 --> 01:02:14,930
Ese mensaje críptico error de segmentación porque estoy tratando de poner en la memoria

988
01:02:14,930 --> 01:02:19,470
un valor como 13 en un lugar que no existe.

989
01:02:19,470 --> 01:02:23,900
El resto del programa puede funcionar bien, pero hasta ese momento no lo hace.

990
01:02:23,900 --> 01:02:25,350
Así que vamos a tratar de contar esta historia.

991
01:02:25,350 --> 01:02:27,830
Volveremos a que una vez que hemos hablado hexagonal.

992
01:02:27,830 --> 01:02:30,290
Volvamos a esto y concluir con esta cosa llamada Binky,

993
01:02:30,290 --> 01:02:33,710
que recuerdo es un profesor de Stanford que se sienta como en casa jugando con plastilina,

994
01:02:33,710 --> 01:02:36,380
para contar la historia de exactamente el mismo programa.

995
01:02:36,380 --> 01:02:40,580
Es sólo alrededor de 3 minutos de duración. Aquí tenemos Binky.

996
01:02:40,580 --> 01:02:45,030
[Hablante masculino en el vídeo] Hey Binky, despierta. Es tiempo para la diversión puntero.

997
01:02:45,030 --> 01:02:50,080
[Binky] ¿Qué es eso? Aprenda acerca de los punteros? Oh, qué bien!

998
01:02:50,080 --> 01:02:53,700
[Hablante masculino] Bueno, para empezar, creo que vamos a necesitar un par de punteros.

999
01:02:53,700 --> 01:02:57,890
>> [Binky] Bueno. Este código asigna 2 punteros que pueden apuntar a enteros.

1000
01:02:57,890 --> 01:03:02,220
[Hablante masculino] Bueno. Bueno, veo que los dos punteros, pero no parecen estar apuntando a nada.

1001
01:03:02,220 --> 01:03:05,550
[Binky] Eso es correcto. Inicialmente, los punteros no apuntan a nada.

1002
01:03:05,550 --> 01:03:09,270
Las cosas que apuntan son llamados pointees y configurarlos es un paso separado.

1003
01:03:09,270 --> 01:03:12,330
[Hablante masculino] Oh, claro, claro. Ya lo sabía. Los pointees están separados.

1004
01:03:12,330 --> 01:03:15,630
Er, así que ¿cómo asignar un pointee?

1005
01:03:15,630 --> 01:03:21,510
[Binky] Bueno. Este código asigna un número entero pointee nuevo, y esta parte se presentan x para que apunte a él.

1006
01:03:21,510 --> 01:03:23,500
[Hablante masculino] Hey, eso se ve mejor.

1007
01:03:23,500 --> 01:03:26,030
Así que haga algo. >> [Binky] Bueno.

1008
01:03:26,030 --> 01:03:30,300
Voy a eliminar la referencia al puntero x para almacenar el número 42 en su pointee.

1009
01:03:30,300 --> 01:03:34,410
Para este truco que voy a necesitar mi varita mágica de la cancelación de referencia.

1010
01:03:34,410 --> 01:03:38,610
[Hablante masculino] Tu varita mágica de la eliminación de referencias? Eso es genial.

1011
01:03:38,610 --> 01:03:44,230
[Binky] Esto es lo que el código parece. Voy a establecer el número y la ... [Apareciendo de sonido]

1012
01:03:44,230 --> 01:03:46,100
[Hablante masculino] Hey mira, ahí va.

1013
01:03:46,100 --> 01:03:50,990
Así que hacer una desreferencia de x sigue la flecha para acceder a su pointee,

1014
01:03:50,990 --> 01:03:53,230
en este caso para almacenar 42 en allí.

1015
01:03:53,230 --> 01:03:57,630
Hey, trata de usarlo para almacenar el número 13 a través del otro puntero, y.

1016
01:03:57,630 --> 01:04:03,250
[Binky] Bueno. Voy a repasar aquí para obtener yy el número 13 establecido

1017
01:04:03,250 --> 01:04:08,360
y luego tomar la vara de eliminación de referencias y sólo ... [Zumbido] Whoa!

1018
01:04:08,360 --> 01:04:10,980
[Hablante masculino] Oh bueno, eso no funcionó.

1019
01:04:10,980 --> 01:04:14,870
>> Digamos, Binky, no creo dereferencing y es una buena idea

1020
01:04:14,870 --> 01:04:17,880
porque la creación de la pointee es un paso separado

1021
01:04:17,880 --> 01:04:19,850
y no creo que alguna vez lo hizo.

1022
01:04:19,850 --> 01:04:21,770
[Binky] Hmm, buen punto.

1023
01:04:21,770 --> 01:04:26,640
[Hablante masculino] Yeah. Nos asignaron el puntero y pero nunca ponerlo para que apunte a un pointee.

1024
01:04:26,640 --> 01:04:28,780
[Binky] Hmm, muy observador.

1025
01:04:28,780 --> 01:04:30,690
[Hablante masculino] Hey, te ves muy bien allí, Binky.

1026
01:04:30,690 --> 01:04:34,160
¿Puedes arreglarlo para que y apunta a la pointee mismo que x? >> [Binky] Claro.

1027
01:04:34,160 --> 01:04:37,100
Voy a usar mi varita mágica de la asignación de puntero.

1028
01:04:37,100 --> 01:04:39,070
[Hablante masculino] ¿Es que va a ser un problema como antes?

1029
01:04:39,070 --> 01:04:40,840
[Binky] No, esto no toca las pointees.

1030
01:04:40,840 --> 01:04:44,780
Sólo cambia un puntero para señalar a la misma cosa que otra. [Apareciendo de sonido]

1031
01:04:44,780 --> 01:04:48,570
[Hablante masculino] Oh, ya veo. Ahora y apunta al mismo lugar que x.

1032
01:04:48,570 --> 01:04:51,140
Así que esperar. Ahora y es fijo. Tiene un pointee.

1033
01:04:51,140 --> 01:04:54,520
Así que usted puede probar la varita de eliminación de referencias volver a enviar los más de 13 años.

1034
01:04:54,520 --> 01:04:58,130
[Binky] Uh, está bien. Aquí va. [Apareciendo de sonido]

1035
01:04:58,130 --> 01:05:01,250
[Hablante masculino] Hey, mira eso. Ahora eliminación de referencias a obras y.

1036
01:05:01,250 --> 01:05:05,200
Y debido a que los punteros que están compartiendo un pointee, ambos ven el 13.

1037
01:05:05,200 --> 01:05:06,910
[Binky] Sí, compartir. Lo que sea.

1038
01:05:06,910 --> 01:05:08,880
>> Así que vamos a cambiar de lugar ahora?

1039
01:05:08,880 --> 01:05:11,420
[Hablante masculino] Oh, mira, estamos fuera de tiempo. >> [Binky] Pero -

1040
01:05:11,420 --> 01:05:13,880
[Hablante masculino] Sólo recuerda las 3 reglas de puntero.

1041
01:05:13,880 --> 01:05:18,630
El número 1, la estructura básica es que usted tiene un puntero y apunta a un pointee.

1042
01:05:18,630 --> 01:05:23,120
Pero el puntero y pointee están separados, y el error común es la creación de un puntero

1043
01:05:23,120 --> 01:05:25,680
pero se olvide de darle un pointee.

1044
01:05:25,680 --> 01:05:29,580
Número 2, desreferencia puntero comienza en el puntero y sigue su flecha sobre

1045
01:05:29,580 --> 01:05:31,060
para acceder a su pointee.

1046
01:05:31,060 --> 01:05:34,340
Como todos sabemos, esto sólo funciona si hay un pointee,

1047
01:05:34,340 --> 01:05:36,460
qué tipo de vuelva a la regla número 1.

1048
01:05:36,460 --> 01:05:39,870
Número 3, asignación de puntero toma un puntero y lo cambia

1049
01:05:39,870 --> 01:05:42,390
para que apunte a la pointee mismo como otro puntero.

1050
01:05:42,390 --> 01:05:45,890
Así que después de la cesión, los 2 punteros que apuntan a la pointee mismo.

1051
01:05:45,890 --> 01:05:47,800
A veces eso se llama compartir.

1052
01:05:47,800 --> 01:05:50,910
>> Y eso es todo lo que hay en realidad. Bye-bye ahora.

1053
01:05:50,910 --> 01:05:55,840
Esto es Binky. Esto es CS50. Nos vemos la semana que viene. [Aplauso]

1054
01:05:55,840 --> 01:05:59,000
>> [CS50.TV]