1
00:00:00,000 --> 00:00:02,270
[Powered by Google Translate] [Semana 2, continuación]

2
00:00:02,270 --> 00:00:04,220
[David J. Malan, Harvard University]

3
00:00:04,220 --> 00:00:06,880
[Esta es CS50. - CS50.TV]

4
00:00:06,880 --> 00:00:10,990
Está bien. Esto es CS50, y este es el fin de semanas 2.

5
00:00:10,990 --> 00:00:14,410
Si usted espera a tener hambre alrededor de esta hora mañana,

6
00:00:14,410 --> 00:00:18,620
Sabemos que vamos a celebrar como un pequeño grupo de mañana, jueves, 1:15 pm.

7
00:00:18,620 --> 00:00:21,360
Hay un URL aquí si desea confirmar su asistencia.

8
00:00:21,360 --> 00:00:26,740
El espacio es limitado, así que por favor, perdóname si el formulario se llena en el momento de rellenar esto.

9
00:00:26,740 --> 00:00:29,300
Otra URL, sin embargo, que podría ser de interés es la siguiente.

10
00:00:29,300 --> 00:00:32,369
En casi un mes, el curso se va a poner a disposición

11
00:00:32,369 --> 00:00:36,890
tanto más ampliamente a través de EDX, a través del cual la gente en el Internet será capaz de seguir adelante,

12
00:00:36,890 --> 00:00:39,380
participar en el curso muy activamente, de hecho.

13
00:00:39,380 --> 00:00:42,270
Se va a utilizar el aparato CS50 CS50 y Comenta

14
00:00:42,270 --> 00:00:45,490
y la mayoría de las herramientas de software diferentes que ya han estado usando este semestre.

15
00:00:45,490 --> 00:00:48,710
Y una de las iniciativas que nos gustaría tomar como un experimento de este año

16
00:00:48,710 --> 00:00:51,930
es ver hasta qué punto podemos traducir el contenido

17
00:00:51,930 --> 00:00:53,960
a otras lenguas habladas y escritas.

18
00:00:53,960 --> 00:00:57,500
Así que si usted podría tener interés en participar en este proyecto

19
00:00:57,500 --> 00:01:02,270
por lo que vamos a ofrecer transcripciones en inglés y subtítulos para las conferencias del curso

20
00:01:02,270 --> 00:01:05,450
y los pantalones cortos y seminarios y secciones y similares,

21
00:01:05,450 --> 00:01:08,200
si usted habla con fluidez y escribir con fluidez otro idioma,

22
00:01:08,200 --> 00:01:12,290
nos encantaría participar en este proyecto mediante el cual se toma en uno o más de los videos,

23
00:01:12,290 --> 00:01:15,200
traducirlos a un lenguaje que conozco bastante bien.

24
00:01:15,200 --> 00:01:18,700
>> Para que os hagáis una idea de la interfaz, hay una interfaz de usuario basada en web

25
00:01:18,700 --> 00:01:22,090
que vamos a utilizar, que creará esencialmente una interfaz de usuario de esta manera.

26
00:01:22,090 --> 00:01:24,290
Esto me estaba enseñando algunos de Halloween hace,

27
00:01:24,290 --> 00:01:27,390
y en el lado derecho hay en negro al lado de estas marcas de tiempo,

28
00:01:27,390 --> 00:01:31,210
podrás ver las varias cosas que salieron de mi boca ese día,

29
00:01:31,210 --> 00:01:34,850
y luego por debajo de la misma será capaz de traducir a otro idioma

30
00:01:34,850 --> 00:01:38,690
exactamente lo que la cartografía es el medio, en este caso, Inglés y, por ejemplo, el español.

31
00:01:38,690 --> 00:01:40,440
Así que en realidad es un muy fácil de usar herramienta.

32
00:01:40,440 --> 00:01:43,370
Puede rebobinar y avanzar rápidamente muy fácilmente con el teclado.

33
00:01:43,370 --> 00:01:47,490
Así que si usted desea participar en este experimento y que sus palabras visto y leído

34
00:01:47,490 --> 00:01:51,850
por miles de potenciales personas por ahí, por favor, no dude en participar.

35
00:01:51,850 --> 00:01:54,350
Una palabra acerca del gatito del lunes.

36
00:01:54,350 --> 00:02:00,350
Para que no nos han enviado un mensaje demasiado miedo, dan cuenta de que, como indican las horas de oficina

37
00:02:00,350 --> 00:02:03,300
y como sugieren las secciones, el diseño del recorrido es mucho

38
00:02:03,300 --> 00:02:07,360
para que los estudiantes colaborando y hablando de trabajar a través de los boletines de problemas

39
00:02:07,360 --> 00:02:11,260
y los problemas juntos, y realmente la línea sólo se reduce a,

40
00:02:11,260 --> 00:02:16,010
una vez más, el trabajo que en última instancia debe ser presentar el suyo propio.

41
00:02:16,010 --> 00:02:18,860
Y así, con toda sinceridad, en horario de oficina es totalmente normal,

42
00:02:18,860 --> 00:02:22,240
está totalmente de esperar, incluso, a estar chateando con algún amigo a tu lado.

43
00:02:22,240 --> 00:02:24,370
>> Si él o ella está luchando con algunos temas y usted es como,

44
00:02:24,370 --> 00:02:27,940
"Oh, bueno, te voy a dar una idea de alguna línea de código que escribí," eso está bien,

45
00:02:27,940 --> 00:02:31,250
que pasa, y eso es muy favorable, creo que, con el proceso de aprendizaje.

46
00:02:31,250 --> 00:02:36,750
Cuando la línea se cruza cuando la cabeza es una especie de inclinación hacia aquí durante unos segundos demasiados

47
00:02:36,750 --> 00:02:41,160
o minutos para que realmente haber sido sólo una oportunidad de desbloqueo para su amigo,

48
00:02:41,160 --> 00:02:44,160
y, ciertamente, cuando las cosas se intercambian a través de correo electrónico y Dropbox y similares,

49
00:02:44,160 --> 00:02:45,640
allí también es la línea.

50
00:02:45,640 --> 00:02:48,620
Así que por todos los medios se sientan cómodos y se sienten animados a charlar con los amigos

51
00:02:48,620 --> 00:02:52,810
y compañeros acerca de conjuntos de procesadores y más y sólo se dan cuenta de que lo que en última instancia, presentar

52
00:02:52,810 --> 00:02:57,340
realmente debe ser el producto de su creación y no otra persona.

53
00:02:57,340 --> 00:03:00,490
Y así uno de los problemas específicos de dominio para pset2,

54
00:03:00,490 --> 00:03:04,740
que saldrá mañana por la noche tarde, es sumergirse en el mundo de la criptografía,

55
00:03:04,740 --> 00:03:08,970
que es el arte de cifrar o codificar la información,

56
00:03:08,970 --> 00:03:12,600
y esto en última instancia se relaciona con el mundo de la seguridad.

57
00:03:12,600 --> 00:03:16,560
Ahora, la seguridad para la mayoría de nosotros se presenta en forma de mecanismos bastante mundanas.

58
00:03:16,560 --> 00:03:19,050
Todos nosotros tenemos nombres de usuario y contraseñas,

59
00:03:19,050 --> 00:03:23,450
y todos tenemos nombres de usuario y contraseñas muy malos, muy probablemente.

60
00:03:23,450 --> 00:03:28,240
>> Si la contraseña es la misma en varios sitios web, que probablemente no es la mejor idea,

61
00:03:28,240 --> 00:03:30,070
como veremos hacia el final del semestre.

62
00:03:30,070 --> 00:03:34,720
Si la contraseña se escribe en una nota adhesiva - no es broma - en el monitor,

63
00:03:34,720 --> 00:03:38,350
que tampoco es necesariamente el mejor diseño, sino un fenómeno bastante común.

64
00:03:38,350 --> 00:03:42,470
Y si usted no está utilizando la criptografía para cifrar las contraseñas,

65
00:03:42,470 --> 00:03:44,210
son particularmente vulnerables.

66
00:03:44,210 --> 00:03:47,270
Así que si usted piensa que está siendo súper inteligente por tener un documento de Word oculto

67
00:03:47,270 --> 00:03:49,910
en algún lugar de su disco duro que tiene todas sus contraseñas

68
00:03:49,910 --> 00:03:53,670
pero está en una carpeta que nadie va a mirar, eso también no es un mecanismo muy seguro.

69
00:03:53,670 --> 00:03:56,990
Y así lo pset2 presentaré es este arte de la criptografía

70
00:03:56,990 --> 00:04:02,010
información y luchando para que cosas como contraseñas son tanto más seguro.

71
00:04:02,010 --> 00:04:05,790
El contexto aquí es que con los datos inseguros

72
00:04:05,790 --> 00:04:07,930
llega una oportunidad para cifrar y para trepar.

73
00:04:07,930 --> 00:04:11,470
Y por lo que este, por ejemplo, es un ejemplo de un mensaje cifrado.

74
00:04:11,470 --> 00:04:14,700
En realidad, esto dice algo en Inglés, pero es evidente que no es totalmente obvio.

75
00:04:14,700 --> 00:04:18,279
Y vamos a llegar al punto de partida hoy a desmenuzar lo que este mensaje secreto aquí es.

76
00:04:18,279 --> 00:04:23,490
Pero en el mundo real de las computadoras, las cosas no parecen que incluso podrían ser frases en inglés.

77
00:04:23,490 --> 00:04:28,430
Por ejemplo, esto es lo que puedes encontrar en un estándar de Linux o Mac o UNIX

78
00:04:28,430 --> 00:04:32,070
en un archivo que fue en otro tiempo llamado el archivo de contraseñas.

79
00:04:32,070 --> 00:04:34,200
>> Hoy en día se han trasladado a otros lugares.

80
00:04:34,200 --> 00:04:39,210
Pero si nos fijamos en el lugar correcto en un sistema, podrás ver no sólo su nombre de usuario

81
00:04:39,210 --> 00:04:43,400
o la de otras personas en el sistema, pero usted verá una versión encriptada de su contraseña.

82
00:04:43,400 --> 00:04:47,980
En efecto, la cripta hay palabra sugiere que las siguientes cosas se cifra,

83
00:04:47,980 --> 00:04:52,680
y esta serie de letras aparentemente al azar y caracteres y números, y así sucesivamente

84
00:04:52,680 --> 00:04:56,480
sólo se puede descifrar en general por conocer algún secreto -

85
00:04:56,480 --> 00:04:58,840
una palabra secreta, un número secreto -

86
00:04:58,840 --> 00:05:03,160
Y de hecho, el arte de la criptografía en última instancia se reduce a confiar de algún tipo

87
00:05:03,160 --> 00:05:05,650
y saber algo que nadie más lo hace.

88
00:05:05,650 --> 00:05:10,090
Así que vamos a explorar en detalle un poco más hoy y en el conjunto de procesadores por venir.

89
00:05:10,090 --> 00:05:12,200
Y ahora una palabra sobre pasa / falla.

90
00:05:12,200 --> 00:05:15,360
Sobre todo porque algunos de ustedes han buceado en pset1, el aparato,

91
00:05:15,360 --> 00:05:19,080
y un mundo muy nuevo para usted, se dan cuenta que las frustraciones y confusiones

92
00:05:19,080 --> 00:05:21,700
y sólo dificultades técnicas son bastante de esperar,

93
00:05:21,700 --> 00:05:24,180
especialmente con el conjunto de procesadores en primer lugar, donde hay tantas cosas nuevas,

94
00:05:24,180 --> 00:05:27,730
sólo a familiarizarse con ls y cd y todos estos comandos arcanos

95
00:05:27,730 --> 00:05:33,050
y un nuevo ambiente, y eso es independiente del material real y la programación en sí.

96
00:05:33,050 --> 00:05:36,940
Así cuenta también que hay ciertamente horas de oficina que existen como una estructura de soporte.

97
00:05:36,940 --> 00:05:38,880
>> Secciones comenzará el próximo domingo.

98
00:05:38,880 --> 00:05:42,960
Pero lo más importante, si te sientes solo que este no es el mundo para ti,

99
00:05:42,960 --> 00:05:44,710
darse cuenta de que en realidad se limita a tomar tiempo.

100
00:05:44,710 --> 00:05:48,600
Y si no fuera por esta oportunidad hace años para mí de tomar una clase de paso / falla,

101
00:05:48,600 --> 00:05:50,990
Honestamente, nunca me hubiera puesto un pie en el aula.

102
00:05:50,990 --> 00:05:53,690
Y usted puede cambiar esto para arriba hasta, digamos, el quinto lunes del curso,

103
00:05:53,690 --> 00:05:58,280
así que si usted está en el borde ahora, darse cuenta de que en lugar de cabeza en algunas otras aguas por completo,

104
00:05:58,280 --> 00:06:01,260
Qué duda considerar simplemente cambiar para pasar / fallar.

105
00:06:01,260 --> 00:06:04,570
Una vez más, no hay realmente esta cultura aquí en Harvard de tomar las cosas de pasa / falla

106
00:06:04,570 --> 00:06:08,670
ya que todo el mundo quiere alcanzar o superar,

107
00:06:08,670 --> 00:06:11,130
pero, francamente, esto es una maravillosa manera de probar algo

108
00:06:11,130 --> 00:06:16,720
que puede no ser familiar para usted, y usted va a terminar haciendo, en la mayoría de los casos, bastante bien,

109
00:06:16,720 --> 00:06:18,210
quizás mucho a su sorpresa.

110
00:06:18,210 --> 00:06:20,980
Y en términos más concretos, lo que creo que pasa / no pasa generalmente lo hace,

111
00:06:20,980 --> 00:06:22,940
especialmente en lo que podría haber experimentado con pset0,

112
00:06:22,940 --> 00:06:26,560
si se pone en 10 horas, 15 horas, 25 horas en algún conjunto de procesadores

113
00:06:26,560 --> 00:06:29,920
y estás golpeando su cabeza contra la pared y se está poniendo súper altas horas de la noche

114
00:06:29,920 --> 00:06:33,950
pero que ha tomado el conjunto de procesadores 90% del camino y simplemente no puedo entender una cosa,

115
00:06:33,950 --> 00:06:36,520
pasa / no pasa realmente toma el borde de una clase como esta,

116
00:06:36,520 --> 00:06:39,100
donde se puede ordenar felizmente de decir: "Bueno, yo sé que no es perfecto,

117
00:06:39,100 --> 00:06:42,350
pero trabajé el culo en esto, estoy bastante contento con el lugar donde terminó "

118
00:06:42,350 --> 00:06:44,850
y que cumpla con las expectativas de pasa / no pasa.

119
00:06:44,850 --> 00:06:47,540
Así que tenlo en cuenta. Está bien.

120
00:06:47,540 --> 00:06:50,520
>> Así que aquellos de ustedes que han tenido dificultades para utilizar la Universidad de Harvard Wi-Fi,

121
00:06:50,520 --> 00:06:54,780
Sabemos que hay un SSID CS50, una conexión Wi-Fi, flotando

122
00:06:54,780 --> 00:06:56,490
que podría tener mejor suerte para.

123
00:06:56,490 --> 00:07:00,130
Es un poco irónico que la contraseña para esto, si usted desea probar la conexión a este

124
00:07:00,130 --> 00:07:08,350
para obtener mejores velocidades - y háganos saber si no es mejor - es 12345, todo el camino hasta el 8

125
00:07:08,350 --> 00:07:10,910
8 porque es más seguro que 5.

126
00:07:10,910 --> 00:07:16,910
Así que si usted necesita la contraseña de Wi-Fi, conexión inalámbrica a CS50 aquí, 12345678,

127
00:07:16,910 --> 00:07:20,380
e incluir en CS50 Hable si usted todavía tiene problemas de conectividad intermitente,

128
00:07:20,380 --> 00:07:25,420
y vamos a dejar que los poderes que se conocen para este espacio. Está bien.

129
00:07:25,420 --> 00:07:32,230
Así que un reclamo rápido, especialmente para aquellos de ustedes que son chicos o chicas fans de todas las cosas de Apple.

130
00:07:32,230 --> 00:07:37,460
Lo que desenterrado de hace unos años era este archivo aquí, iUnlock.c,

131
00:07:37,460 --> 00:07:39,930
sólo para tipo de concreto más y más complejos

132
00:07:39,930 --> 00:07:42,560
algunos de los programas en C más básicas que hemos estado escribiendo.

133
00:07:42,560 --> 00:07:46,910
Así que abrí este archivo, iUnlock.c. Está disponible en la página de Lecturas para hoy.

134
00:07:46,910 --> 00:07:49,810
En el lado izquierdo se ve una larga lista de funciones.

135
00:07:49,810 --> 00:07:53,230
Así que el tipo que escribió esto escribió una gran cantidad de funciones, más que principal.

136
00:07:53,230 --> 00:07:57,340
Él utilizó una gran cantidad de bibliotecas aquí, y, si empezamos a desplazarse a través de

137
00:07:57,340 --> 00:08:04,890
lo que esto es, es la primera, creo, crack para el iPhone original.

138
00:08:04,890 --> 00:08:09,830
>> Cuando se quería hacer jailbreak al iPhone original, lo que significa que desanudar de AT & T

139
00:08:09,830 --> 00:08:13,710
y en realidad instalar software especial en él y hacer cosas que Apple no quería que la gente lo hace,

140
00:08:13,710 --> 00:08:18,480
alguien se tomó el tiempo para averiguar exactamente cómo podrían explotar fallos de software,

141
00:08:18,480 --> 00:08:22,690
errores, errores en el software de Apple, y así nació iUnlock.c--

142
00:08:22,690 --> 00:08:26,760
que si se compila en el equipo y lo instaló en un iPhone

143
00:08:26,760 --> 00:08:29,430
que estaba conectado a su ordenador a través de, por ejemplo, un cable USB,

144
00:08:29,430 --> 00:08:32,450
esto le daría privilegios de administrador o root en tu iPhone

145
00:08:32,450 --> 00:08:34,620
y le permiten hacer casi todo lo que quieras.

146
00:08:34,620 --> 00:08:36,400
Y así ha sido este fascinante gato y al ratón

147
00:08:36,400 --> 00:08:39,340
entre Apple y el resto del mundo, en particular en lo que, al igual que muchas empresas,

148
00:08:39,340 --> 00:08:43,350
tratar de bloquear sus cosas abajo de manera que sólo se puede hacer con ella lo que tenía planeado.

149
00:08:43,350 --> 00:08:47,360
Pero gracias a gente como esta y la comprensión de detalles de bajo nivel -

150
00:08:47,360 --> 00:08:50,830
y en este caso la programación C - y muchas de las construcciones conocidas

151
00:08:50,830 --> 00:08:55,280
que hemos empezado a jugar, usted puede realmente aprovechar el hardware

152
00:08:55,280 --> 00:08:59,250
de una manera mejor le parezca y no necesariamente una entidad corporativa.

153
00:08:59,250 --> 00:09:01,600
Así, por ejemplo, no tengo ni idea de lo que todo esto está haciendo,

154
00:09:01,600 --> 00:09:03,580
GetVersion pero suena bastante sencillo,

155
00:09:03,580 --> 00:09:05,710
y parece que esta es una función que esta persona escribió.

156
00:09:05,710 --> 00:09:09,250
Se necesita algún tipo de número entero como argumento, no devuelve nada,

157
00:09:09,250 --> 00:09:13,710
pero parece bucle con un bucle aquí y si una condición, si la interrupción condición,

158
00:09:13,710 --> 00:09:16,770
y de alguna manera se relaciona con los números de versión si se desplaza hacia abajo,

159
00:09:16,770 --> 00:09:19,650
a pesar de que muchas de estas palabras clave van a ser nuevos.

160
00:09:19,650 --> 00:09:22,590
Y hay un montón de funciones en aquí nunca hemos visto y que no vea nunca

161
00:09:22,590 --> 00:09:24,350
en el transcurso del semestre.

162
00:09:24,350 --> 00:09:29,160
>> Al final del día, sigue las mismas reglas y la lógica que hemos estado jugando con hasta el momento.

163
00:09:29,160 --> 00:09:34,340
Así que esto es demasiado viejo para romper sus 3s iPhone o días estos 4s 5s o pronto,

164
00:09:34,340 --> 00:09:38,830
pero sepan que todo está muy deriva de este mundo que hemos buceado en.

165
00:09:38,830 --> 00:09:42,280
Echemos un vistazo a un pequeño ejemplo más simple:

166
00:09:42,280 --> 00:09:46,260
éste, sólo para entrar en calor con un poco de sintaxis y también otro tipo de datos

167
00:09:46,260 --> 00:09:48,910
que ya hemos hablado, pero no han visto realmente en C.

168
00:09:48,910 --> 00:09:53,670
Se trata de un archivo llamado positive1.c, y, por los comentarios en la parte superior

169
00:09:53,670 --> 00:09:56,070
esto sólo requiere que el usuario proporcione un número positivo.

170
00:09:56,070 --> 00:09:59,910
Así que es un ejemplo de un bucle do-while, que es agradable para los programas de usuario interactivas

171
00:09:59,910 --> 00:10:02,070
donde tiene que decirle al usuario que haga algo,

172
00:10:02,070 --> 00:10:05,530
y si ellos no cooperan les gritas o rechazar su entrada.

173
00:10:05,530 --> 00:10:10,480
Un ejemplo: yo voy a hacer líneas 19 a la 24

174
00:10:10,480 --> 00:10:14,620
siempre y cuando el usuario no se me ha dado un número positivo.

175
00:10:14,620 --> 00:10:21,340
Este detalle aquí en la línea 18, ¿por qué yo declaro n por encima de este bucle entero construir

176
00:10:21,340 --> 00:10:26,870
en contraposición a la derecha al lado de la línea 22 en el que realmente importa para obtener n? Si.

177
00:10:26,870 --> 00:10:29,330
[Estudiante] Scope. >> Si, por lo que este problema de alcance.

178
00:10:29,330 --> 00:10:31,770
Y, en términos sencillos, ¿qué alcance se refiere?

179
00:10:34,880 --> 00:10:41,560
Si. >> [Respuesta de los estudiantes inaudible] >> ¿Puedes hablar un poco más alto?

180
00:10:41,560 --> 00:10:45,440
[Estudiante] Donde se puede acceder a esa variable. >> Perfect.

181
00:10:45,440 --> 00:10:47,610
Donde se puede acceder a una variable en particular.

182
00:10:47,610 --> 00:10:50,990
Y, en general, la regla general hasta ahora ha sido que el alcance de una variable

183
00:10:50,990 --> 00:10:56,140
se define por las llaves más recientes que he visto.

184
00:10:56,140 --> 00:11:03,070
>> Y así, en este caso, si he cometido el error de declarar n en la línea 22, la línea iba a funcionar.

185
00:11:03,070 --> 00:11:10,840
Me gustaría conseguir un int, por lo que lo pone en esa variable n en la línea 22,

186
00:11:10,840 --> 00:11:17,060
pero qué línea de código ahora no tendría ni idea de lo que estoy hablando? >> [Estudiante] 25.

187
00:11:17,060 --> 00:11:23,840
[Malan] 25, y resulta que 24 así porque en este caso cae fuera de las llaves.

188
00:11:23,840 --> 00:11:28,550
Así que un poco de una molestia, pero muy fácil de resolver con sólo declarar la variable

189
00:11:28,550 --> 00:11:30,700
fuera de la propia función.

190
00:11:30,700 --> 00:11:32,760
Ya veremos el día de hoy se puede ir un paso más allá

191
00:11:32,760 --> 00:11:34,940
y que incluso podría ser un poco perezoso.

192
00:11:34,940 --> 00:11:39,660
Y esto no es recomendable en general, sino que incluso podría volverse perezoso

193
00:11:39,660 --> 00:11:44,150
y poner una variable a nivel mundial, por así decir, no dentro de una función, no dentro de un bucle,

194
00:11:44,150 --> 00:11:49,800
sino en el propio archivo, fuera de todas las funciones que usted ha escrito, como lo hice aquí en la línea 15.

195
00:11:49,800 --> 00:11:55,220
Esto es generalmente mal visto, pero se dan cuenta que es una solución a veces a otros problemas,

196
00:11:55,220 --> 00:11:56,910
ya que con el tiempo veremos.

197
00:11:56,910 --> 00:11:59,500
Así que por ahora vamos a dejarlo así, pero vamos a ver si podemos reescribir esta

198
00:11:59,500 --> 00:12:02,360
sólo para empezar a expresarnos de manera diferente.

199
00:12:02,360 --> 00:12:05,550
Este programa, sólo para que quede claro, es positive1.

200
00:12:05,550 --> 00:12:11,980
Déjame ir por delante aquí y en mi ventana de terminal hacer positive1, Enter.

201
00:12:11,980 --> 00:12:15,080
Compila bien. Voy a correr positive1, pulse Enter.

202
00:12:15,080 --> 00:12:19,250
Exijo que me des un entero positivo. Diré -1. Eso no funcionó.

203
00:12:19,250 --> 00:12:22,340
0, 99. Esto parece que funciona.

204
00:12:22,340 --> 00:12:25,310
Quizás no es la prueba más rigurosa, pero al menos es una comprobación de validez agradable

205
00:12:25,310 --> 00:12:27,100
que estamos en el camino correcto.

206
00:12:27,100 --> 00:12:29,570
>> Así que ahora vamos a seguir adelante y abrir la versión 2 de la presente,

207
00:12:29,570 --> 00:12:32,800
y lo que es diferente ya?

208
00:12:32,800 --> 00:12:39,030
Pone en práctica la misma cosa, pero lo que está saltando como claramente diferente esta vez?

209
00:12:40,790 --> 00:12:47,090
Esta bool en verde. Se destaca en verde, esta palabra clave se conoce como bool, que es un tipo de datos.

210
00:12:47,090 --> 00:12:50,510
No viene integrado en todas las versiones de C.

211
00:12:50,510 --> 00:12:52,650
Tienes que incluir una biblioteca específica.

212
00:12:52,650 --> 00:12:56,460
En nuestro caso, incluí la biblioteca CS50 para que tengamos acceso a bool.

213
00:12:56,460 --> 00:12:59,860
Sin embargo, en la línea 18, parece que tenemos un valor booleano llamado aquí agradecidos.

214
00:12:59,860 --> 00:13:02,190
Podría haber llamado a esta nada, pero me llamó agradecido

215
00:13:02,190 --> 00:13:04,750
sólo para transmitir algún tipo de significado semántico.

216
00:13:04,750 --> 00:13:07,700
Así que al principio de la línea 18, estoy agradecido al parecer no

217
00:13:07,700 --> 00:13:12,230
porque el valor agradecido Boolean se inicializa en false en la línea 18.

218
00:13:12,230 --> 00:13:16,500
Y entonces parece que lo que he hecho aquí, en las líneas 21 a 23

219
00:13:16,500 --> 00:13:19,200
se acabo tipo de reescribir mi lógica.

220
00:13:19,200 --> 00:13:26,100
Así que no funcionalmente diferentes, pero en la línea 22 ahora compruebo si el int el usuario ha proporcionado

221
00:13:26,100 --> 00:13:31,360
es mayor que 0, entonces simplemente cambiar el valor de agradecer a true.

222
00:13:31,360 --> 00:13:35,590
¿Y por qué lo hago? Debido a que en la línea 25, al parecer voy a comprobar una condición.

223
00:13:35,590 --> 00:13:39,760
¿Es este bucle while agradecido es falso.

224
00:13:39,760 --> 00:13:42,960
Así que me propuso esto como una alternativa a la versión 1

225
00:13:42,960 --> 00:13:47,050
porque es al menos un poco más intuitivo quizás, es un poco más de tierra en Inglés.

226
00:13:47,050 --> 00:13:51,980
Así que haga lo siguiente mientras no estás agradecido o agradecida mientras que es falso.

227
00:13:51,980 --> 00:13:56,220
Y esta vez yo también, aparentemente, no me importa recordar lo que el usuario escribió en

228
00:13:56,220 --> 00:14:00,050
porque no hay ningún aviso de n variable, lo que en realidad, una pequeña mentira piadosa allí.

229
00:14:00,050 --> 00:14:03,290
>> Funcionalmente, el programa es un poco diferente una vez que lleguemos al fondo de la cuestión

230
00:14:03,290 --> 00:14:04,960
porque no voy a recordar lo que n es.

231
00:14:04,960 --> 00:14:09,120
Pero yo quería demostrar que también en este caso a pesar de que hemos visto getInt

232
00:14:09,120 --> 00:14:13,780
y GetString se utiliza en el lado derecho de un signo igual hasta ahora

233
00:14:13,780 --> 00:14:17,310
para que recordemos el valor, técnicamente, no es estrictamente necesario.

234
00:14:17,310 --> 00:14:20,290
Si por cualquier razón usted no les importa para guardar el valor,

235
00:14:20,290 --> 00:14:25,540
lo que desea es comprobar el valor, observe que simplemente podemos escribir esto como getInt,

236
00:14:25,540 --> 00:14:27,320
abierto paren, paren cerca.

237
00:14:27,320 --> 00:14:30,570
Esta función va a devolver un valor, como lo hemos estado diciendo.

238
00:14:30,570 --> 00:14:32,220
Se te va a devolver un int.

239
00:14:32,220 --> 00:14:34,460
Y así, si mentalmente pensar de que esto ocurra,

240
00:14:34,460 --> 00:14:38,190
cuando escribo en 99, getInt devuelve el número 99,

241
00:14:38,190 --> 00:14:41,840
y por lo tanto conceptualmente, es como si mi código eran en realidad esto.

242
00:14:41,840 --> 00:14:45,950
Así que si 99 es en realidad mayor que 0, entonces se convierte en verdad agradecido,

243
00:14:45,950 --> 00:14:50,810
luego la línea 25 se da cuenta ooh, hemos terminado porque ahora estoy agradecido,

244
00:14:50,810 --> 00:14:53,970
y en la línea 26, que simplemente decir: "Gracias por el entero positivo!"

245
00:14:53,970 --> 00:14:55,960
lo que resultó ser.

246
00:14:55,960 --> 00:14:59,140
Ahora vamos a hacer el azúcar sintáctico leve aquí, por así decirlo.

247
00:14:59,140 --> 00:15:04,670
Vamos a ver si podemos limpiar esta línea 25 con esta variante de la tercera y última en positive3.

248
00:15:04,670 --> 00:15:13,600
>> Tenga en cuenta que la única diferencia ahora es qué línea de código? >> [Estudiante] 25. >> [Malan] Sí, 25.

249
00:15:13,600 --> 00:15:17,680
Y no hemos visto realmente este truco todavía, pero nos hicieron ver el signo de exclamación en lunes,

250
00:15:17,680 --> 00:15:21,070
que denota qué? >> [Los estudiantes] no. No >> o negación.

251
00:15:21,070 --> 00:15:23,510
Así que toma un valor booleano y voltear su valor.

252
00:15:23,510 --> 00:15:25,810
Cierto convierte en falso, falso se hace realidad.

253
00:15:25,810 --> 00:15:30,420
Así que esto, propongo, es aún un poco más intuitiva manera de escribir el código

254
00:15:30,420 --> 00:15:33,430
porque todavía agradecido inicializar en false, lo sigo haciendo lo siguiente,

255
00:15:33,430 --> 00:15:36,010
Puse agradecido a true cuando llegue el momento,

256
00:15:36,010 --> 00:15:40,880
pero ahora usted puede realmente sólo traducir el código verbal izquierda a derecha,

257
00:15:40,880 --> 00:15:45,630
mientras que (gracias!), ya que el punto explosión o exclamación denota la noción de no

258
00:15:45,630 --> 00:15:47,580
así que mientras no agradecido.

259
00:15:47,580 --> 00:15:49,900
Así que de nuevo, no hemos introducido nuevos conceptos en sí.

260
00:15:49,900 --> 00:15:53,730
Hablamos de Booleanos atrás cuando jugamos con Scratch,

261
00:15:53,730 --> 00:15:56,720
pero se dan cuenta ahora podemos empezar a escribir nuestro código de muchas maneras diferentes.

262
00:15:56,720 --> 00:16:01,060
Por tanto, y en pset1 si usted es una especie de lucha por descubrir la manera de escribir algún programa,

263
00:16:01,060 --> 00:16:04,340
más probable es que estás de suerte porque no puede haber cualquier número de soluciones

264
00:16:04,340 --> 00:16:06,110
que le puede suceder a.

265
00:16:06,110 --> 00:16:10,500
Por ejemplo, esto es sólo 3 de incluso el más simple de los programas. Está bien.

266
00:16:10,500 --> 00:16:14,200
Y ahora recuerdo el lunes nos fuimos en esta nota con valores de retorno.

267
00:16:14,200 --> 00:16:18,450
Así que para la primera vez que escribimos un programa que no sólo tiene principal;

268
00:16:18,450 --> 00:16:22,550
también tiene su propia función personalizada que escribí aquí.

269
00:16:22,550 --> 00:16:26,810
Así, en la línea 31 a la 34 He implementado una función de cubo.

270
00:16:26,810 --> 00:16:30,240
No es complejo. Es sólo a * a * a en este caso.

271
00:16:30,240 --> 00:16:34,750
Pero lo importante de esto es que estoy tomando de entrada en forma de un

272
00:16:34,750 --> 00:16:39,180
y me estoy volviendo salida en forma de * a * a.

273
00:16:39,180 --> 00:16:43,560
Así que ahora tengo la capacidad, tanto como solía hacerlo con prinf solo,

274
00:16:43,560 --> 00:16:47,240
llamar a esta función llamando a la función de cubo.

275
00:16:47,240 --> 00:16:51,970
>> Y la función de cubo tiene alguna información, y la función devuelve un cubo de salida.

276
00:16:51,970 --> 00:16:56,960
Por el contrario, printf acabo de hacer algo.

277
00:16:56,960 --> 00:17:00,840
No volvió todo lo que nos importaba, a pesar de que en un aparte que devuelve ningún valor;

278
00:17:00,840 --> 00:17:03,110
que acaba generalmente lo ignoran.

279
00:17:03,110 --> 00:17:06,510
Printf acabo de hacer algo. Tenía un efecto secundario de la impresión en la pantalla.

280
00:17:06,510 --> 00:17:11,770
En cambio aquí, tenemos la función de cubo, que en realidad devuelve algo.

281
00:17:11,770 --> 00:17:15,520
Así que para aquellos que están familiarizados con esto, es una idea bastante sencilla.

282
00:17:15,520 --> 00:17:19,640
Pero para aquellos menos familiarizados con la idea de pasar en las entradas y salidas de volver,

283
00:17:19,640 --> 00:17:21,950
vamos a tratar sólo algo simple super.

284
00:17:21,950 --> 00:17:25,490
¿Hay alguien que viene cómodo en el escenario brevemente?

285
00:17:25,490 --> 00:17:28,040
Usted tiene que estar cómodo con una cámara en usted también. ¿Sí? Bien.

286
00:17:28,040 --> 00:17:31,240
¿Cuál es tu nombre? >> [Estudiante] Ken. >> Ken. Está bien. Ken, vamos arriba.

287
00:17:31,240 --> 00:17:35,050
Ken va a ser una función del tipo aquí.

288
00:17:35,050 --> 00:17:38,720
Vamos a seguir adelante y hacer esto. Vayamos un poco sofisticado.

289
00:17:38,720 --> 00:17:42,260
Gusto en conocerlo. Bienvenido al centro del escenario. Está bien.

290
00:17:42,260 --> 00:17:46,640
Vamos a golpear el botón aquí. Está bien.

291
00:17:46,640 --> 00:17:49,820
Así que aquí tienes una pizarra moderna,

292
00:17:49,820 --> 00:17:53,470
y lo que yo soy es la función principal, por ejemplo,

293
00:17:53,470 --> 00:17:56,460
y no tengo un iPad en la mano.

294
00:17:56,460 --> 00:17:59,710
>> Yo no me acuerdo cómo - Bueno, no puedo decir que.

295
00:17:59,710 --> 00:18:02,480
Yo realmente no tengo buena letra,

296
00:18:02,480 --> 00:18:05,520
y por lo tanto, quiero que imprimir algo en la pantalla para mí.

297
00:18:05,520 --> 00:18:12,040
Estoy siendo el programa principal, y yo voy a tener que decir esto

298
00:18:12,040 --> 00:18:16,720
escribiendo en mi garabatos y luego pasar que una entrada.

299
00:18:16,720 --> 00:18:20,400
Tan tonto aunque este ejercicio es, la noción de funciones y llamar a una función

300
00:18:20,400 --> 00:18:22,400
y devuelve una función realmente se reduce a esto.

301
00:18:22,400 --> 00:18:26,260
Estoy principal, que acabo de escribir printf, entre comillas algo en la pantalla,

302
00:18:26,260 --> 00:18:29,110
Estoy ejecutando este programa, y ​​tan pronto como se llama printf,

303
00:18:29,110 --> 00:18:32,880
Toma un argumento o un parámetro a veces entre comillas dobles.

304
00:18:32,880 --> 00:18:35,880
Aquí está el argumento. Lo estoy pasando a Ken.

305
00:18:35,880 --> 00:18:39,020
Él es un cuadro negro escrito un número de años

306
00:18:39,020 --> 00:18:41,510
que al parecer sólo sabe imprimir cosas en la pantalla.

307
00:18:41,510 --> 00:18:43,150
Así que ejecutar.

308
00:18:49,280 --> 00:18:51,280
Eso no es malo. Muy bueno.

309
00:18:51,280 --> 00:18:55,510
Así que ahora se lleva a cabo la ejecución de Ken. ¿Tiene que darme nada a cambio?

310
00:18:55,510 --> 00:18:57,470
No es que hemos visto hasta el momento.

311
00:18:57,470 --> 00:19:00,460
Una vez más, es en realidad printf devuelve un número, pero vamos a ignorar que por ahora

312
00:19:00,460 --> 00:19:03,470
porque nunca he utilizado. Así que eso es todo por Ken.

313
00:19:03,470 --> 00:19:08,580
Y ahora principal toma el control de nuevo el programa

314
00:19:08,580 --> 00:19:11,060
porque esa línea de código, printf, se lleva a cabo la ejecución.

315
00:19:11,060 --> 00:19:14,050
Y nos ocupamos de nuestro camino, la ejecución de cualquier otras líneas están ahí.

316
00:19:14,050 --> 00:19:17,320
Así que ahora vamos a probar un ejemplo un poco diferente.

317
00:19:17,320 --> 00:19:24,940
Esta vez aquí primero vamos a borrar la pantalla, y esta vez vamos a hacer la función de medición de volumen,

318
00:19:24,940 --> 00:19:27,080
pero esta vez, espero que un valor de salida.

319
00:19:27,080 --> 00:19:29,180
>> Así que vamos a seguir adelante y hacerlo.

320
00:19:29,180 --> 00:19:35,790
Ahora tengo una línea de código que dice que x se cúbica de x.

321
00:19:41,370 --> 00:19:46,370
La línea de código, el recuerdo, se ve así: x = cubo (x);

322
00:19:46,370 --> 00:19:50,930
Entonces, ¿cómo se va a trabajar? Vamos a seguir adelante y darle una pantalla en blanco de nuevo.

323
00:19:50,930 --> 00:19:54,070
Voy a escribir ahora el valor de x,

324
00:19:54,070 --> 00:20:01,400
que en este momento pasa a ser, digamos, 2 para mantener las cosas simples.

325
00:20:01,400 --> 00:20:06,150
He escrito en un pedazo de papel el valor de 2, lo cual es mi valor x.

326
00:20:06,150 --> 00:20:10,920
Se lo entrego a Ken. >> Y acabo de escribir la respuesta? >> Sí, vamos a escribir la respuesta.

327
00:20:12,760 --> 00:20:18,940
Bien. Y ahora me tiene que devolver algo. Perfecto. Niza segue.

328
00:20:18,940 --> 00:20:23,120
Así que ahora me pasa de nuevo el valor de 8 en este caso, y qué debo hacer con él?

329
00:20:23,120 --> 00:20:28,250
En realidad - vamos a ver, obtener este derecho. ¿Qué voy a hacer con él?

330
00:20:28,250 --> 00:20:33,440
Ahora me voy a tomar este valor y almacenarlo en realidad en esos mismos bits en la memoria.

331
00:20:33,440 --> 00:20:35,170
Pero note que soy una especie de lucha aquí.

332
00:20:35,170 --> 00:20:38,210
Estoy un poco confundido porque donde puedo realmente escribir el valor de x,

333
00:20:38,210 --> 00:20:43,150
porque lo que acabas de hacer es físicamente Ken mano un pedazo de papel que tenía el valor 2,

334
00:20:43,150 --> 00:20:46,590
que era x, y, de hecho, eso es precisamente lo que sucedió.

335
00:20:46,590 --> 00:20:50,210
Así que resulta que cuando se llama a la función y se le pasa un argumento

336
00:20:50,210 --> 00:20:53,290
como hola, mundo, ni se le pasa un argumento como el 2,

337
00:20:53,290 --> 00:20:57,110
en general, está pasando una copia de ese argumento.

338
00:20:57,110 --> 00:21:00,730
Y así como yo anoté el número 2 aquí y se lo dio a Ken,

339
00:21:00,730 --> 00:21:04,720
eso quiere decir que todavía tengo una copia del valor 2 en algún lugar

340
00:21:04,720 --> 00:21:08,890
porque de hecho, ahora que lo he conseguido volver el valor 8, tengo que volver en la memoria RAM

341
00:21:08,890 --> 00:21:12,130
y en realidad anotar 8, donde una vez tuve el número 2.

342
00:21:12,130 --> 00:21:16,950
Así visualmente, recuerda esta idea de pasar en, literalmente, una copia del valor.

343
00:21:16,950 --> 00:21:20,780
>> Ken hace sus cosas, me da algo de vuelta - en este caso un valor como 8 -

344
00:21:20,780 --> 00:21:24,980
y luego tengo que hacer algo con ese valor si quiero mantenerlo ahí.

345
00:21:24,980 --> 00:21:29,650
Así que todo esto volverá a ser demasiado familiar en poco tiempo.

346
00:21:29,650 --> 00:21:34,920
Muchas gracias por esta demostración aquí, Ken. [Aplauso]

347
00:21:34,920 --> 00:21:36,920
Muy bien hecho.

348
00:21:36,920 --> 00:21:42,690
Vamos a ver cómo eso se relaciona en última instancia, a parte de la función de llamada que hemos estado haciendo aquí.

349
00:21:42,690 --> 00:21:47,910
Déjame ir por delante y nos lleve de nuevo al ejemplo cubicación aquí.

350
00:21:47,910 --> 00:21:53,300
Tenga en cuenta que si queremos realmente empezar a tomar este más futuro,

351
00:21:53,300 --> 00:21:57,570
vamos a tener que tener en cuenta el hecho de que el número x que está siendo pasado por aquí

352
00:21:57,570 --> 00:22:01,530
es diferente de lo que realmente está pasando en la función.

353
00:22:01,530 --> 00:22:05,880
Así que de nuevo, este paso por copia va a ser muy afín en un momento.

354
00:22:05,880 --> 00:22:09,580
Vamos a echar un vistazo a algo que no acaba de funcionar bien todavía.

355
00:22:09,580 --> 00:22:13,250
Voy a seguir adelante y abrir un ejemplo calesa tercera, que está viciado por la naturaleza,

356
00:22:13,250 --> 00:22:18,550
y se llama buggy3 e implementa una función de intercambio.

357
00:22:18,550 --> 00:22:25,110
Aquí tenemos una función principal que ha x e y arbitrariamente inicializa a 1 y 2, respectivamente.

358
00:22:25,110 --> 00:22:27,700
Podríamos utilizar getInt, pero sólo necesitamos un ejercicio simple,

359
00:22:27,700 --> 00:22:30,170
por lo que es codificada como 1 y 2.

360
00:22:30,170 --> 00:22:35,340
En las líneas 21 y 22, que al parecer imprimir x e y, una por línea.

361
00:22:35,340 --> 00:22:39,720
A continuación, en la línea 23, sostengo que estoy cambiando estos valores, punto, punto, punto.

362
00:22:39,720 --> 00:22:44,170
Me aparentemente llamar a una función en la línea 24 de intercambio llamada que dura 2 argumentos.

363
00:22:44,170 --> 00:22:48,300
Está totalmente de fiar para las funciones que tomar 2 argumentos. Hemos visto printf hacerlo ya.

364
00:22:48,300 --> 00:22:51,830
>> Así intercambio aparentemente toma x e y, y como sugiere su nombre,

365
00:22:51,830 --> 00:22:54,670
Espero que esto va a cambiar estos 2 valores.

366
00:22:54,670 --> 00:23:00,090
Así que me dicen en la línea 25 "cambiaron!" y reimprimir x e y

367
00:23:00,090 --> 00:23:03,070
bajo el supuesto de que han sido efectivamente intercambiados.

368
00:23:03,070 --> 00:23:06,080
Pero si realmente ejecutar este programa - que me abra una ventana de terminal,

369
00:23:06,080 --> 00:23:09,860
quiero dejar buggy3 - como su nombre lo indica, esto no va a terminar bien

370
00:23:09,860 --> 00:23:15,770
porque cuando pulse la tecla Enter, nótese que x es 1, y es 2,

371
00:23:15,770 --> 00:23:19,420
y sin embargo, al final del programa, todavía son, de hecho, el mismo.

372
00:23:19,420 --> 00:23:22,960
Así que basado en la demostración acaba con Ken, lo que realmente está pasando?

373
00:23:22,960 --> 00:23:28,710
¡Entremos en esta función swap. Es súper corto. No es más que unas pocas líneas de código de tiempo.

374
00:23:28,710 --> 00:23:34,520
Pero ¿cuál es el problema fundamental que debe basarse en la simple historia dice aquí con Ken?

375
00:23:34,520 --> 00:23:36,670
¿Por qué el canje de rompe?

376
00:23:36,670 --> 00:23:39,660
[Estudiante] Usted está almacenando una copia, no la variable.

377
00:23:39,660 --> 00:23:43,980
Exactamente. Estamos en guardar una copia, no la variable en sí.

378
00:23:43,980 --> 00:23:47,170
En otras palabras, de intercambio aparentemente tiene 2 argumentos, un int,

379
00:23:47,170 --> 00:23:49,370
y es llamado arbitrariamente a y b,

380
00:23:49,370 --> 00:23:54,420
y aquí he pasado en x e y, que son, respectivamente, 1 y 2,

381
00:23:54,420 --> 00:23:58,770
pero no estoy literalmente pasando x, no estoy literalmente pasando y,

382
00:23:58,770 --> 00:24:01,450
Estoy pasando una copia de x y una copia de y.

383
00:24:01,450 --> 00:24:04,510
Es casi como si usted copiar y pegar en canje

384
00:24:04,510 --> 00:24:07,810
los valores que desea para manipular realmente.

385
00:24:07,810 --> 00:24:14,480
Así que si ese es el caso, cuando el inicio del programa la ejecución de la línea 35 después de 36 años,

386
00:24:14,480 --> 00:24:18,650
cuando llegue a la línea 37, en este momento de la historia, ¿cuál es el valor de a?

387
00:24:21,040 --> 00:24:25,050
En este punto de la historia, línea 37, ¿cuál es el valor de una en este momento? >> [Estudiante] 1.

388
00:24:25,050 --> 00:24:29,280
[Malan] Simplemente debe ser 1, a la derecha, ya que x se pasa como primer argumento,

389
00:24:29,280 --> 00:24:33,080
y esta función sólo arbitrariamente está llamando a su primer argumento.

390
00:24:33,080 --> 00:24:38,200
Del mismo modo es Y el segundo argumento, y es simplemente llamar a la b arbitrariamente segundo argumento.

391
00:24:38,200 --> 00:24:40,990
>> Esta dicotomía es en realidad bastante simple explicación. Piensa en ello.

392
00:24:40,990 --> 00:24:43,320
Ninguno de nosotros ha conocido a la persona que escribió printf,

393
00:24:43,320 --> 00:24:50,770
por lo que seguramente, él o ella no tiene idea de lo que nuestras variables de 30 años más tarde se iba a llamar.

394
00:24:50,770 --> 00:24:56,650
Así que tiene que haber una distinción entre lo que llaman las variables en las funciones que estás escribiendo

395
00:24:56,650 --> 00:25:02,080
y lo que ustedes llaman las variables en las funciones que está llamando o utilizando.

396
00:25:02,080 --> 00:25:05,340
En otras palabras, he escrito mis variables como x e y,

397
00:25:05,340 --> 00:25:08,890
pero si alguien había escrito la función de intercambio, él o ella seguramente no sabría

398
00:25:08,890 --> 00:25:10,690
lo que mis variables se va a llamar,

399
00:25:10,690 --> 00:25:13,830
así darse cuenta de que esto es por qué tiene esa dualidad de nombres.

400
00:25:13,830 --> 00:25:16,750
Técnicamente, yo podría hacer esto por casualidad,

401
00:25:16,750 --> 00:25:20,080
pero aún así se pasa como copias.

402
00:25:20,080 --> 00:25:23,650
Sólo sería una pura coincidencia estéticamente si esa persona que escribió intercambio

403
00:25:23,650 --> 00:25:26,150
había utilizado los mismos nombres.

404
00:25:26,150 --> 00:25:32,370
Así que en este punto de la historia, línea 37, a es 1, b es 2, y ahora me dedico a intercambiarlas.

405
00:25:32,370 --> 00:25:34,900
En primer lugar, quisiera realmente hacer esto mucho más simple.

406
00:25:34,900 --> 00:25:36,690
No sé cuáles son esas 3 líneas de código hacían.

407
00:25:36,690 --> 00:25:41,210
Permítanme hacer esto: b = a; a = b; hecho.

408
00:25:41,210 --> 00:25:44,690
¿Por qué esta roto, lógicamente?

409
00:25:46,490 --> 00:25:48,900
Es algo de lo intuitivo, ¿verdad?

410
00:25:48,900 --> 00:25:52,560
Así una y B se convierte en b se convierte en una,

411
00:25:52,560 --> 00:25:57,730
pero el problema es que tan pronto como se ejecuta la línea 37, ¿cuál es el valor de a y b?

412
00:25:57,730 --> 00:26:03,410
Lo mismo, 1, porque ha paliza, por así decirlo, has cambiado b sea igual a.

413
00:26:03,410 --> 00:26:08,890
Así que una vez que se ha ejecutado la línea 37, que está muy bien, ahora tienes 2 copias de la número 1

414
00:26:08,890 --> 00:26:13,350
dentro de esta función, por lo que a continuación, cuando usted dice en la línea 38 a = b,

415
00:26:13,350 --> 00:26:17,640
eres un poco jodido porque estás asignando 1 a 1.

416
00:26:17,640 --> 00:26:20,580
Usted ha perdido el tipo de valor que le importaba.

417
00:26:20,580 --> 00:26:23,220
Así que en la versión original de este, observe lo que hice.

418
00:26:23,220 --> 00:26:26,850
Yo en cambio tuvo una tercera línea de código que se veía así.

419
00:26:26,850 --> 00:26:28,580
Yo declaro una variable temporal.

420
00:26:28,580 --> 00:26:32,170
>> Tmp es un nombre muy común para una variable temporal, y es un int

421
00:26:32,170 --> 00:26:34,580
porque tiene que coincidir con lo que yo quiero hacer una copia de.

422
00:26:34,580 --> 00:26:39,770
Puedo guardar una copia de dentro de tmp, así que una vez que la línea 37 se ha ejecutado,

423
00:26:39,770 --> 00:26:45,860
el valor de a es - comprobación de validez rápida - 1, el valor de b es 2,

424
00:26:45,860 --> 00:26:48,970
y el valor de tmp es también 1.

425
00:26:48,970 --> 00:26:52,060
Así que ahora ejecutar la línea 38.

426
00:26:52,060 --> 00:27:00,540
Una vez que la línea 38 se ejecuta, una toma el valor de b. Y b fue de 2, por lo que ahora es un 2.

427
00:27:00,540 --> 00:27:05,210
Así que en este punto de la historia, a es 2, b es 2, y tmp es 1,

428
00:27:05,210 --> 00:27:11,060
por lo que ahora, lógicamente, podemos valorar sólo tmp plop en la b y ya está.

429
00:27:11,060 --> 00:27:12,800
Para ello hemos resuelto ese problema.

430
00:27:12,800 --> 00:27:17,720
Por desgracia, cuando ejecuto este programa en esta forma, en realidad no cambiar ningún valor.

431
00:27:17,720 --> 00:27:20,100
Pero para que quede claro, ¿por qué?

432
00:27:23,660 --> 00:27:26,450
He arreglado el problema lógico de hace un momento,

433
00:27:26,450 --> 00:27:31,020
pero de nuevo, si ejecuta este programa, x e y no cambian

434
00:27:31,020 --> 00:27:33,310
por el final de la ejecución del programa.

435
00:27:33,310 --> 00:27:37,220
[Comentario estudiante inaudible] >> No hemos devuelto nada, así que eso es cierto.

436
00:27:37,220 --> 00:27:39,670
Pero resulta que hay un pequeño problema aquí, porque hasta el momento,

437
00:27:39,670 --> 00:27:44,170
lo único que he sido capaz de volver es una cosa, y ésta es una restricción de la C.

438
00:27:44,170 --> 00:27:49,070
Sólo puede volver realmente un valor, en cuyo caso estoy un poco atascado aquí

439
00:27:49,070 --> 00:27:53,310
porque pude devolver el nuevo valor de x o podía devolver el nuevo valor de y,

440
00:27:53,310 --> 00:27:55,190
pero quiero que los dos de vuelta.

441
00:27:55,190 --> 00:27:58,650
Así que regresa no es la solución simple aquí.

442
00:27:58,650 --> 00:28:01,710
Pero el problema fundamental es ¿por qué? ¿Qué hemos cambiado en realidad?

443
00:28:01,710 --> 00:28:04,190
[Estudiante] a y b. >> A y b.

444
00:28:04,190 --> 00:28:08,230
Pero a y b son copias de x e y, por lo que acabamos de hacer todo este trabajo,

445
00:28:08,230 --> 00:28:11,650
Acabamos de pasar 3 minutos hablando acerca de la función de intercambio y los 3 de estas variables,

446
00:28:11,650 --> 00:28:15,420
y eso es genial, perfectamente correcto en el aislamiento,

447
00:28:15,420 --> 00:28:20,740
pero a y b del alcance sólo está en estas líneas aquí.

448
00:28:20,740 --> 00:28:24,790
>> Así como un bucle, si se declara un entero i dentro del bucle for,

449
00:28:24,790 --> 00:28:28,760
Del mismo modo, si usted está declarando dentro de a y b de la función que usted ha escrito,

450
00:28:28,760 --> 00:28:33,320
solo son válidos dentro de esa función, lo que significa que tan pronto como intercambio se realiza ejecutando

451
00:28:33,320 --> 00:28:38,470
y vamos a partir de la línea 24 a la línea 25, x e y no han cambiado en absoluto.

452
00:28:38,470 --> 00:28:42,790
Usted acaba de perder un montón de tiempo que se tarda copias de variables.

453
00:28:42,790 --> 00:28:47,010
Así resulta que la solución a esto es en realidad no evidente.

454
00:28:47,010 --> 00:28:50,670
No es más que suficiente para devolver valores porque sólo podemos devolver un valor,

455
00:28:50,670 --> 00:28:53,470
y realmente quiero cambiar tanto x como y, al mismo tiempo,

456
00:28:53,470 --> 00:28:55,210
así que vamos a tener que volver a esto.

457
00:28:55,210 --> 00:29:01,020
Pero por ahora, darse cuenta de que el problema fundamental deriva del hecho de que a y b son copias

458
00:29:01,020 --> 00:29:03,630
y están en su propio ámbito.

459
00:29:03,630 --> 00:29:05,050
Vamos a tratar de resolver esto de alguna manera.

460
00:29:05,050 --> 00:29:11,250
Permítanme retroceder en realidad aquí y abren, digamos, una cuarta variante de esto, buggy4.

461
00:29:11,250 --> 00:29:13,370
¿Qué pasa con esto?

462
00:29:13,370 --> 00:29:17,810
Este es un problema similar pero más sencillo que mirar antes de tomar una puñalada en su solución.

463
00:29:17,810 --> 00:29:24,190
Este programa se llama incremento, y al parecer se inicializa un entero x a 1 en la línea 18.

464
00:29:24,190 --> 00:29:28,150
Entonces me dicen x es 1, entonces me dicen "Incrementar ..."

465
00:29:28,150 --> 00:29:33,730
Entonces llame incremento, pero luego en las líneas 22 y 23, que dicen que ha sido incrementado,

466
00:29:33,730 --> 00:29:40,220
Yo reclamo x ahora es lo que es - 2, probablemente - pero este programa está libre de errores.

467
00:29:40,220 --> 00:29:42,610
¿Cuál es el problema?

468
00:29:43,440 --> 00:29:50,160
Si. >> [Respuesta de los estudiantes inaudible] >> Exactamente.

469
00:29:50,160 --> 00:29:52,490
Así que x ha sido declarada, por supuesto, en la línea 18.

470
00:29:52,490 --> 00:29:54,700
Es dentro de llaves principal.

471
00:29:54,700 --> 00:29:58,440
Así que la respuesta simple es que mientras que x existe aquí,

472
00:29:58,440 --> 00:30:03,930
que no existe en la línea 32, por lo que este programa realmente ni siquiera se compilará.

473
00:30:03,930 --> 00:30:07,940
El compilador cuando intento compilar este código va a gritarme

474
00:30:07,940 --> 00:30:14,100
sobre algún identificador no declarado o algo por el estilo. De hecho, vamos a intentarlo.

475
00:30:14,100 --> 00:30:18,470
Se trata de hacer buggy4. Ahí está.

476
00:30:18,470 --> 00:30:22,110
El uso de 'x' identificador no declarado en la línea 32.

477
00:30:22,110 --> 00:30:25,580
Y, de hecho, vamos a ser más explícito aquí hoy para que esto sea útil

478
00:30:25,580 --> 00:30:27,580
en horas de oficina y en casa.

479
00:30:27,580 --> 00:30:29,300
>> Tenga en cuenta que es un poco críptico escrito.

480
00:30:29,300 --> 00:30:37,270
Pero el hecho de que tiene Clang nos gritaba, diciendo buggy4.c: 32:5, es realmente útil.

481
00:30:37,270 --> 00:30:42,050
Esto significa que el error está en la línea 32 en la posición de carácter 5.

482
00:30:42,050 --> 00:30:46,700
Así 1, 2, 3, 4, 5. Eso es, en efecto, donde el problema es.

483
00:30:46,700 --> 00:30:49,790
Y también, también, tener en cuenta en las horas de oficina y en casa, tengo suerte aquí.

484
00:30:49,790 --> 00:30:52,990
Tengo un error. Va a ser relativamente fácil de solucionar.

485
00:30:52,990 --> 00:30:55,990
Pero si tienes una pantalla llena de mensajes de error abrumadoras,

486
00:30:55,990 --> 00:31:00,330
otra vez darse cuenta de que el situado más abajo podría ser un síntoma de la más alta.

487
00:31:00,330 --> 00:31:03,450
Así que siempre persigue a sus errores, de arriba hacia abajo

488
00:31:03,450 --> 00:31:05,820
porque no sólo podría ser un efecto en cadena

489
00:31:05,820 --> 00:31:09,240
que sugiere que tiene problemas mucho más de lo que realmente hacen.

490
00:31:09,240 --> 00:31:15,150
Entonces, ¿cómo podemos solucionar este problema si mi objetivo es incrementar x? >> [Estudiante] x Haga global.

491
00:31:15,150 --> 00:31:17,060
Bueno, por lo que podemos hacer x global.

492
00:31:17,060 --> 00:31:20,480
Vamos a tomar el atajo que me advirtió acerca de antes, pero demonios, sólo necesitamos una solución rápida,

493
00:31:20,480 --> 00:31:25,730
así que vamos a decir int x aquí. Eso hace que x global.

494
00:31:25,730 --> 00:31:31,800
Así que ahora principal tiene acceso a la misma y el incremento tiene acceso a ella,

495
00:31:31,800 --> 00:31:34,110
y así que déjame ir adelante y compilar este momento.

496
00:31:34,110 --> 00:31:37,630
Hacer buggy4, Enter. Parece compilar ahora.

497
00:31:37,630 --> 00:31:41,230
Vamos a correr buggy4. Y parece que funciona realmente.

498
00:31:41,230 --> 00:31:45,150
Esta es una de esas cosas que se hacen como yo digo, no lo que hago,

499
00:31:45,150 --> 00:31:47,010
como acabo de hacer aquí, ya que en general,

500
00:31:47,010 --> 00:31:50,440
nuestros programas se van a poner mucho más interesante y mucho más que esto,

501
00:31:50,440 --> 00:31:56,390
y si la solución a problemas de la vida se acaba de poner todas las variables en la parte superior de su archivo,

502
00:31:56,390 --> 00:31:59,690
muy rápidamente qué programas se horriblemente difícil de manejar.

503
00:31:59,690 --> 00:32:02,190
Se hace más difícil de idear nuevos nombres de variables,

504
00:32:02,190 --> 00:32:05,240
se hace más difícil entender qué variable está haciendo qué,

505
00:32:05,240 --> 00:32:08,460
y así, en general, esto no es una buena solución.

506
00:32:08,460 --> 00:32:10,030
Así que vamos a hacer esto mejor.

507
00:32:10,030 --> 00:32:12,160
No queremos utilizar una variable global aquí.

508
00:32:12,160 --> 00:32:16,240
>> Yo quiero incrementar x, así que obviamente podría -

509
00:32:16,240 --> 00:32:18,670
al final del día, esto es un poco de una historia tonta porque simplemente hacer esto -

510
00:32:18,670 --> 00:32:24,450
pero si yo no sabía nada de ese operador o que no se le permitió cambiarlo principal en sí,

511
00:32:24,450 --> 00:32:30,730
¿Cómo podría yo poner en práctica Ken acá esta vez no para incrementar cubo pero a?

512
00:32:31,380 --> 00:32:33,190
¿Cómo puedo cambiar esto de aquí? Si.

513
00:32:33,190 --> 00:32:38,480
[Estudiante] Pass en x y volver luego [inaudible] >> Bien, bien.

514
00:32:38,480 --> 00:32:41,900
¿Por qué no puedo pasar en x y entonces en vez de devolverlo,

515
00:32:41,900 --> 00:32:44,870
¿Por qué no me lo devuelva x + 1.

516
00:32:44,870 --> 00:32:47,710
Un par de cosas que tienen que cambiar aquí. Estoy en el camino correcto.

517
00:32:47,710 --> 00:32:49,770
¿Qué más necesita para modificar? Alguien más. Si.

518
00:32:49,770 --> 00:32:51,740
[Respuesta de los estudiantes inaudible]

519
00:32:51,740 --> 00:32:54,730
Tengo que cambiar el tipo de retorno de incremento porque no se anulará.

520
00:32:54,730 --> 00:32:57,780
Nada Void medios se están devolviendo, pero es evidente que ahora es,

521
00:32:57,780 --> 00:32:59,830
así que esto tiene que cambiar a - >> [estudiante] int.

522
00:32:59,830 --> 00:33:02,740
int para ser coherente con lo que en realidad estoy regresando.

523
00:33:02,740 --> 00:33:05,180
Ahora, otra cosa es aún con errores aquí. Si.

524
00:33:05,180 --> 00:33:08,400
[Respuesta de los estudiantes inaudible] >> [Malan] Así que necesito para incrementar x?

525
00:33:08,400 --> 00:33:12,080
[Respuesta de los estudiantes inaudible] >> [Malan] Ah, así que tengo que pasar x.

526
00:33:12,080 --> 00:33:16,660
Así que tengo que hacer esto aquí. >> [Comentario estudiante inaudible]

527
00:33:16,660 --> 00:33:20,050
[Malan] Así que el prototipo, tengo que cambiar esto aquí.

528
00:33:20,050 --> 00:33:22,930
Así que esto tiene que ser un int, esto tiene que ser -

529
00:33:22,930 --> 00:33:25,620
hmm, yo en realidad tienen un error aquí. Vamos a arreglar esto primero.

530
00:33:25,620 --> 00:33:29,590
¿Cuál debe ser esta realidad? Tiene que ser un algo int.

531
00:33:29,590 --> 00:33:32,700
Podría ser x, pero, francamente, si usted empieza a llamar a todos los de su x variables,

532
00:33:32,700 --> 00:33:35,390
que va a recibir menos y menos clara cuál es cuál.

533
00:33:35,390 --> 00:33:39,560
>> Así que vamos a elegir arbitrariamente una nomenclatura diferente para las funciones de mi ayudador;

534
00:33:39,560 --> 00:33:41,940
las funciones que estoy escribiendo. Lo llamaremos a, o podríamos llamarlo -

535
00:33:41,940 --> 00:33:45,010
Digamos que es el número sea aún más explícito.

536
00:33:45,010 --> 00:33:47,560
Así que tengo que devolver todo lo que el número es más 1,

537
00:33:47,560 --> 00:33:50,740
y ahora tengo que cambiar una cosa aquí y otra cosa aquí.

538
00:33:50,740 --> 00:33:54,350
¿Qué tengo que cambiar en la línea 21 en primer lugar? >> [Respuesta de los estudiantes inaudible]

539
00:33:54,350 --> 00:33:57,610
[Malan] tengo que asignar a x. No puedo llamar incremento (x).

540
00:33:57,610 --> 00:34:01,960
Necesito recordar la respuesta al cambiar el valor de x en el lado izquierdo.

541
00:34:01,960 --> 00:34:04,680
Y a pesar de que x se encuentra ahora en la izquierda y la derecha, que es totalmente bien

542
00:34:04,680 --> 00:34:08,860
debido a que el lado derecho se ejecuta primero y luego se dejó caer en la cosa de la izquierda -

543
00:34:08,860 --> 00:34:10,600
x en este caso.

544
00:34:10,600 --> 00:34:12,159
Y por último, esta es una solución fácil ahora.

545
00:34:12,159 --> 00:34:17,230
Esto sólo debe coincidir con lo que está abajo, el número int.

546
00:34:17,230 --> 00:34:20,570
Así que un montón de cambios para una función realmente estúpido

547
00:34:20,570 --> 00:34:24,420
pero representativa de las cosas que cada vez querrá hacer.

548
00:34:24,420 --> 00:34:27,090
Así que buggy4. Me he cagado en alguna parte.

549
00:34:27,090 --> 00:34:30,139
Oh, Dios mío. Cinco errores en un programa de 6 líneas.

550
00:34:30,139 --> 00:34:35,690
Entonces, ¿qué hay de malo en la línea 18, el carácter 5?

551
00:34:35,690 --> 00:34:39,610
Así que tengo que declarar este tipo int.

552
00:34:39,610 --> 00:34:41,920
Vamos a ver. Hay un montón de otros errores.

553
00:34:41,920 --> 00:34:47,010
Oh, Dios mío - 19, 18, 21 -, pero de nuevo, vamos a borrar la pantalla, L Control de aquí,

554
00:34:47,010 --> 00:34:49,380
y vuelva a ejecutar Clang.

555
00:34:49,380 --> 00:34:51,340
Así que 5 problemas que en realidad es sólo una.

556
00:34:51,340 --> 00:34:57,520
Así que ahora vamos a ejecutar buggy4, Enter. ¡Menos mal, x se ha incrementado correctamente.

557
00:34:57,520 --> 00:35:02,720
Está bien. Cualquier pregunta sobre la forma de incrementar los números? Si.

558
00:35:02,720 --> 00:35:09,870
[Pregunta estudiante inaudible] >> Buena pregunta.

559
00:35:09,870 --> 00:35:14,220
¿Cómo es que sólo puedo cambiar x a número y el programa sabrá de inmediato?

560
00:35:14,220 --> 00:35:16,200
>> Una vez más, pensar en ella como esta abstracción.

561
00:35:16,200 --> 00:35:21,600
Así que si yo soy principal y Ken es el incremento, francamente, no me importa lo que Ken llama a su iPad.

562
00:35:21,600 --> 00:35:26,570
No me importa lo que él llama cualquier cosa que tenga que ver con su implementación de esta funcionalidad.

563
00:35:26,570 --> 00:35:33,340
Este es un detalle de implementación que yo, principal, no tienen que preocuparse.

564
00:35:33,340 --> 00:35:38,250
Y así, simplemente cambiando constantemente dentro de la función - y el número de serie aquí aquí -

565
00:35:38,250 --> 00:35:40,960
es todo lo que toma tanto tiempo como yo recompilar.

566
00:35:40,960 --> 00:35:44,180
Es algo así como si se piensa en muchos de nosotros, aquellos que tengan licencias de conducir

567
00:35:44,180 --> 00:35:46,770
que han impulsado o si usted incluso ha conducido en un coche,

568
00:35:46,770 --> 00:35:50,950
la mayoría de nosotros no tenemos idea de cómo funciona un coche bajo la campana.

569
00:35:50,950 --> 00:35:54,970
Y, literalmente, si se abre el capó, la mayoría de nosotros - yo incluido -

570
00:35:54,970 --> 00:35:56,940
no vamos a saber realmente lo que estamos viendo,

571
00:35:56,940 --> 00:35:59,220
especie de que se puede sentir con cosas como esta ahora mismo.

572
00:35:59,220 --> 00:36:01,480
Pero en realidad no tienen que cuidar cómo el coche funciona,

573
00:36:01,480 --> 00:36:05,970
que no tienen que cuidar lo que todas las varillas y pistones y los cables en el interior del coche

574
00:36:05,970 --> 00:36:08,160
en realidad están haciendo.

575
00:36:08,160 --> 00:36:12,770
Así que algo como lo que ustedes llaman el pistón no tiene importancia aquí en este caso. La misma idea.

576
00:36:12,770 --> 00:36:25,300
Si. >> [Pregunta estudiante inaudible]

577
00:36:25,300 --> 00:36:29,180
Si hay más usos de la variable xa momento antes,

578
00:36:29,180 --> 00:36:32,150
usted, el programador, tendría que cambiar todas partes.

579
00:36:32,150 --> 00:36:36,600
O usted podría literalmente hacer Archivo, Menú, y luego Buscar, Reemplazar - algo así -

580
00:36:36,600 --> 00:36:39,170
pero vas a tener que hacer esos cambios por su cuenta.

581
00:36:39,170 --> 00:36:47,450
Hay que ser coherente. >> [Estudiante] Si hay varias variables [inaudible]

582
00:36:47,450 --> 00:36:53,100
Una orden particular, como aquí, si se trataba de int otro número? >> [Estudiante] Correcto.

583
00:36:53,100 --> 00:36:56,590
[Malan] Yeah. Orden importa cuando se llama a la función.

584
00:36:56,590 --> 00:37:00,050
>> Así que si me estaban llamando incremento aquí con algo algo coma,

585
00:37:00,050 --> 00:37:01,680
hay una correlación directa.

586
00:37:01,680 --> 00:37:05,690
La primera variable, como se llame, se hace una copia del primer argumento por aquí.

587
00:37:05,690 --> 00:37:07,760
Lo siento. Esto no debería ser un paréntesis.

588
00:37:07,760 --> 00:37:11,490
Las líneas del segundo argumento para arriba con el segundo. Así orden, sí, importa. Está bien.

589
00:37:11,490 --> 00:37:17,020
Lo siento. Tomé el camino más largo para llegar allí. Otras preguntas? Está bien.

590
00:37:17,020 --> 00:37:20,610
Así que vamos a ver si podemos pintar un cuadro de lo que realmente está pasando aquí

591
00:37:20,610 --> 00:37:23,090
debajo de la campana, por así decirlo.

592
00:37:23,090 --> 00:37:26,640
Este es un rectángulo que podría representar la memoria de su computadora.

593
00:37:26,640 --> 00:37:30,970
Incluso si usted no tiene idea de cómo funciona la memoria RAM o cómo funciona,

594
00:37:30,970 --> 00:37:33,940
al menos se supone que tiene racimos de él en estos días.

595
00:37:33,940 --> 00:37:36,280
Tienes megabytes de ella, tienes gigabytes de la misma,

596
00:37:36,280 --> 00:37:40,870
y sabemos por semana 0 que un byte es qué? >> [Estudiante] 8 bits.

597
00:37:40,870 --> 00:37:42,950
8 bits, ¿no? Así que 8 ceros y 1.

598
00:37:42,950 --> 00:37:45,880
Así que si su equipo tiene un giga de RAM, 2 gigas de RAM en estos días,

599
00:37:45,880 --> 00:37:55,030
Tiene un billón o 2 millones de bytes de memoria o bits de aproximadamente 8 millones de dólares o 16 mil millones

600
00:37:55,030 --> 00:37:56,890
dentro de su equipo.

601
00:37:56,890 --> 00:38:00,590
A diferencia de la pequeña Wooly Willy ejemplo, no es típicamente partículas magnéticas más.

602
00:38:00,590 --> 00:38:04,450
Cada vez más - en los ordenadores portátiles por lo menos - es unidades de estado sólido, SSD,

603
00:38:04,450 --> 00:38:08,580
que simplemente no tienen partes móviles. Todo es electrónico. Es toda la electricidad basada en.

604
00:38:08,580 --> 00:38:14,060
Así que piensa de este rectángulo como apenas representa el 1 o 2 gigabytes de memoria que tiene.

605
00:38:14,060 --> 00:38:16,020
>> Así que es un trozo de memoria.

606
00:38:16,020 --> 00:38:19,830
El mundo de la informática tiene una especie de particiones de

607
00:38:19,830 --> 00:38:22,950
trozos de memoria para hacer cosas diferentes.

608
00:38:22,950 --> 00:38:27,190
Por ejemplo, si esta es la memoria RAM de su computadora, como lo sugiere el rectángulo allí,

609
00:38:27,190 --> 00:38:31,130
resulta que, por convención, en la parte superior de la memoria RAM, por así decirlo,

610
00:38:31,130 --> 00:38:33,660
generalmente es lo que se llama un segmento de texto.

611
00:38:33,660 --> 00:38:36,740
Esos son el 0 y 1 que haya recopilado.

612
00:38:36,740 --> 00:38:39,020
Por eso, cuando hemos mirado debajo de la capucha lo a.out es,

613
00:38:39,020 --> 00:38:41,980
todos estos 0s y 1s, cuando se ejecuta un programa,

614
00:38:41,980 --> 00:38:46,290
los 0s y 1s son cargados desde el disco duro en algo que se llama memoria RAM,

615
00:38:46,290 --> 00:38:49,320
y en la RAM se las coloca en la parte superior.

616
00:38:49,320 --> 00:38:52,770
Mientras tanto, usted tiene otras cosas: inicializar los datos, desinicializar datos.

617
00:38:52,770 --> 00:38:57,510
Esas dos franjas de memoria se refieren a las variables globales, que no se utilizan a menudo

618
00:38:57,510 --> 00:39:00,760
pero a veces si lo hace, terminan allí también.

619
00:39:00,760 --> 00:39:04,260
Entonces hay algunas otras cosas: variables de entorno, que no vamos a pasar mucho tiempo en adelante,

620
00:39:04,260 --> 00:39:06,860
pero 2 cosas importantes que volver lo largo del semestre,

621
00:39:06,860 --> 00:39:08,550
pila y pila.

622
00:39:08,550 --> 00:39:12,210
Así que la mayoría de la memoria del equipo está reservado al ejecutar un programa

623
00:39:12,210 --> 00:39:15,370
por algo que se llama la pila y algo que se llama el montón.

624
00:39:15,370 --> 00:39:18,840
No vamos a hablar sobre el montón de hoy, pero vamos a hablar de la pila.

625
00:39:18,840 --> 00:39:24,600
La pila está destinado a evocar la visual de las bandejas de comida en el comedor Mather House

626
00:39:24,600 --> 00:39:28,110
o donde quiera que sea, donde el personal de comedor limpiarlas todos los días,

627
00:39:28,110 --> 00:39:30,180
que ellos comparan desde el suelo hacia arriba,

628
00:39:30,180 --> 00:39:34,550
y del mismo modo, en la memoria, no es la idea de poner algo en una pila,

629
00:39:34,550 --> 00:39:36,860
poner algo en una pila, poner algo en una pila.

630
00:39:36,860 --> 00:39:38,240
Y ¿qué es lo que queremos decir con esto?

631
00:39:38,240 --> 00:39:41,860
>> Vamos a ampliar en casi la mitad inferior de la imagen, la memoria RAM de su computadora,

632
00:39:41,860 --> 00:39:44,330
a proponer la siguiente.

633
00:39:44,330 --> 00:39:48,170
Resulta que cuando se ejecuta un programa como a.out o hello -

634
00:39:48,170 --> 00:39:50,100
cualquiera que sea el programa que has escrito -

635
00:39:50,100 --> 00:39:54,020
de nuevo, los 0s y 1s son cargados desde el disco duro, que es un almacenamiento prolongado,

636
00:39:54,020 --> 00:39:57,230
permanece allí incluso cuando se tire de la clavija, se carga en la memoria RAM.

637
00:39:57,230 --> 00:40:00,610
RAM es más rápido que los discos duros - es más pequeño que los discos duros -

638
00:40:00,610 --> 00:40:03,300
pero es donde los programas en vivo mientras está en funcionamiento.

639
00:40:03,300 --> 00:40:08,230
Así se hace doble clic en un programa en un Mac o PC, se carga desde el disco duro a la RAM.

640
00:40:08,230 --> 00:40:11,520
Tan pronto como se carga en la memoria RAM, el go 0s y 1s en la parte superior forma,

641
00:40:11,520 --> 00:40:16,610
el segmento de texto llamado, pero tan pronto como el programa realmente se pone en marcha,

642
00:40:16,610 --> 00:40:21,360
la principal función es llamada, y principal, como hemos visto, a menudo tiene variables locales,

643
00:40:21,360 --> 00:40:24,870
y tiene enteros y cadenas y caracteres y similares.

644
00:40:24,870 --> 00:40:29,180
Así que si tu programa que usted ha escrito o del programa que haya hecho doble clic

645
00:40:29,180 --> 00:40:32,970
utilizado algunas variables dentro de la principal,

646
00:40:32,970 --> 00:40:37,240
terminan en la parte inferior de la pila de la memoria, por así decirlo.

647
00:40:37,240 --> 00:40:39,410
Más concretamente, ¿qué significa esto realmente?

648
00:40:39,410 --> 00:40:48,450
Esto sólo significa que si íbamos a numerar los bytes de RAM en el ordenador,

649
00:40:48,450 --> 00:40:55,750
notar que este podría ser el número de bytes 0, este podría ser el número de bytes 1, 2, 3, 4, 5, 6,

650
00:40:55,750 --> 00:41:01,480
todo el camino hasta 2 mil millones sería todo el camino hasta allí en la parte superior.

651
00:41:01,480 --> 00:41:05,880
En otras palabras, cuando se habla de la memoria RAM o en términos de bytes,

652
00:41:05,880 --> 00:41:11,500
sólo significa que alguien ha decidido a contar lo que cada uno de esos trozos de memoria.

653
00:41:11,500 --> 00:41:16,650
Así que cuando usted necesita 32 bits para un int o necesita 8 bits para un char,

654
00:41:16,650 --> 00:41:18,840
¿de dónde van a parar a la memoria?

655
00:41:18,840 --> 00:41:22,350
>> Conceptualmente, se acaba de terminar en el fondo de esta cosa llamada la pila.

656
00:41:22,350 --> 00:41:25,870
Pero lo interesante ahora es cuando llama a una función principal -

657
00:41:25,870 --> 00:41:28,750
supongamos una función llamada foo, sólo un nombre arbitrario -

658
00:41:28,750 --> 00:41:32,330
lo que sucede es principal está en la parte inferior de esta pila de la memoria;

659
00:41:32,330 --> 00:41:35,680
foo ahora se coloca en la parte superior de la memoria principal.

660
00:41:35,680 --> 00:41:40,990
Así que las variables locales que se acaban foo tipo de vista conceptual encima de los de principal.

661
00:41:40,990 --> 00:41:47,070
Si foo llama a otra función llamada bar, aquellas variables terminan aquí.

662
00:41:47,070 --> 00:41:50,120
Si la barra pide algo más, aquí, aquí, aquí.

663
00:41:50,120 --> 00:41:53,830
Así que lo que es interesante acerca de la ejecución de un programa es que al llamar a funciones

664
00:41:53,830 --> 00:41:57,750
y como esas funciones y llamar a funciones como las funciones que llaman a funciones,

665
00:41:57,750 --> 00:42:01,470
construir el edificio esta pila de funciones en la memoria.

666
00:42:01,470 --> 00:42:06,890
Y sólo una vez devuelve una función no comienza a recibir esa memoria espalda.

667
00:42:06,890 --> 00:42:10,860
Así que una de las maneras más fáciles de ejecutar fuera de la memoria en un programa informático

668
00:42:10,860 --> 00:42:14,360
es escribir funciones que nunca vuelven.

669
00:42:14,360 --> 00:42:18,900
Así, por ejemplo, vamos a demostrar como mucho con un programa intencionalmente buggy.

670
00:42:18,900 --> 00:42:22,230
Déjenme seguir adelante y hacer # include,

671
00:42:22,230 --> 00:42:25,000
int main (void)

672
00:42:25,000 --> 00:42:32,940
y yo voy a hacer mientras que (2> 1), lo que probablemente no va a cambiar en nosotros,

673
00:42:32,940 --> 00:42:37,560
y déjame seguir adelante ahora y hacer printf.

674
00:42:37,560 --> 00:42:40,700
En realidad, eso va a ser menos interesante visualmente. Vamos a hacer esto.

675
00:42:40,700 --> 00:42:50,240
Para int i = 0; i> 0 - vamos a cometer este error - i + +.

676
00:42:50,240 --> 00:42:52,720
Y no printf aquí. Vamos a practicar lo que predicaba.

677
00:42:52,720 --> 00:43:00,190
Vamos a echar un método aquí, chorus vacío, y vamos a decir int i,

678
00:43:00,190 --> 00:43:06,830
y luego voy a decir printf - no, vamos a hacer esto más interesante.

679
00:43:06,830 --> 00:43:15,790
Que en realidad no imprime nada en absoluto. Vamos a ello: chorus (i).

680
00:43:15,790 --> 00:43:20,390
Está bien. Así que esto tiene fallos porque ¿por qué?

681
00:43:20,390 --> 00:43:23,380
Estoy haciendo esto como voy porque el programa no hace nada de interés.

682
00:43:23,380 --> 00:43:25,320
>> Pero ese no es el objetivo.

683
00:43:25,320 --> 00:43:29,630
El objetivo es escribir un programa que tiene como principal función hace lo que, al parecer?

684
00:43:30,720 --> 00:43:32,860
Llame a sí mismo. Y en realidad, no necesitamos el bucle.

685
00:43:32,860 --> 00:43:37,200
Vamos a simplificar aún esto sólo para no perder de vista realmente el error fundamental.

686
00:43:37,200 --> 00:43:39,640
Principales llamadas coro para cantar algunos coros,

687
00:43:39,640 --> 00:43:41,440
entonces hice algo estúpido y yo tuvimos coro coro llamada

688
00:43:41,440 --> 00:43:43,760
porque supuse que alguien más iba a ponerlo en práctica, tal vez,

689
00:43:43,760 --> 00:43:47,210
y ahora esto no se va a compilar todavía. Tengo que hacer qué?

690
00:43:47,210 --> 00:43:49,970
Necesito el prototipo, recuerda.

691
00:43:49,970 --> 00:43:56,110
Así que tengo que tener aquí coro void (int i);

692
00:43:56,110 --> 00:43:59,210
Así que ahora si me voy por aquí - en realidad, vamos a utilizar la ventana más grande.

693
00:43:59,210 --> 00:44:01,980
Vamos a seguir adelante y hacer coros.

694
00:44:01,980 --> 00:44:06,490
Vamos a seguir adelante y hacer coros.

695
00:44:06,490 --> 00:44:08,370
El uso de identificador no declarado i.

696
00:44:08,370 --> 00:44:12,500
Oh, eso fue estúpido. No necesitamos el argumento. Vamos a hacer esto.

697
00:44:12,500 --> 00:44:16,370
Me hubiera gustado haber comenzado de esta manera. Hubiera sido un programa mucho más fácil de escribir.

698
00:44:16,370 --> 00:44:25,590
Ya está. Ahora vamos a ir a mi ventana de terminal, ejecute de nuevo Clang, y aquí vamos.

699
00:44:25,590 --> 00:44:28,460
Eso fue muy rápido.

700
00:44:28,460 --> 00:44:31,150
Lo que en realidad acaba de ocurrir, sin embargo?

701
00:44:31,150 --> 00:44:33,730
Bueno, ahora voy a añadir la línea de impresión para que podamos ver.

702
00:44:33,730 --> 00:44:43,490
Permítanme decir printf ("Estoy aquí") - sin variables. Lo dejaremos así.

703
00:44:43,490 --> 00:44:47,480
Permítanme hacer volver a ejecutar. Permítanme volver a ejecutar coro.

704
00:44:47,480 --> 00:44:57,380
Y ... vamos. Sigue adelante.

705
00:44:57,380 --> 00:44:59,930
Como acotación al margen, ¿por qué no lo ha derrumbado todavía?

706
00:44:59,930 --> 00:45:02,080
El fallo de segmentación pasó súper rápido antes.

707
00:45:02,080 --> 00:45:06,570
[Respuesta de los estudiantes inaudible] >> Exactamente. Así que se necesita tiempo para imprimir, ¿verdad?

708
00:45:06,570 --> 00:45:08,610
Solo se necesita más trabajo por parte del equipo.

709
00:45:08,610 --> 00:45:10,620
Y ahí está: Segmentation fault.

710
00:45:10,620 --> 00:45:12,340
>> Así notar cuán rápido ejecutar programas.

711
00:45:12,340 --> 00:45:14,130
Si no está imprimiendo algo, super rápido.

712
00:45:14,130 --> 00:45:18,770
Pero todavía tengo este error de segmentación porque lo que estaba pasando?

713
00:45:18,770 --> 00:45:21,210
Si usted piensa acerca de cómo la memoria del equipo se presenta,

714
00:45:21,210 --> 00:45:28,740
esto pasa a ser principal, pero aquí vamos a llamar a este coro, y vamos a llamar a este coro.

715
00:45:28,740 --> 00:45:34,550
Y ahora si hago mi estética bien, esto es sólo va a decir coro, coro, coro,

716
00:45:34,550 --> 00:45:40,550
coro, coro, coro, coro, hasta la saciedad, y, finalmente, ¿qué va a pasar?

717
00:45:40,550 --> 00:45:45,630
Si el cuadro grande, literalmente, es la siguiente, ¿qué le pasa conceptual?

718
00:45:46,520 --> 00:45:48,630
Los excesos de la pila la pila.

719
00:45:48,630 --> 00:45:51,940
O, peor aún, que acaba de invadir todo, incluyendo el segmento de texto,

720
00:45:51,940 --> 00:45:54,590
que es el 0 y 1 que representa el programa.

721
00:45:54,590 --> 00:45:57,080
En resumen, esto es sólo super, super mal.

722
00:45:57,080 --> 00:45:58,830
Su programa se ha disparado fuera de control.

723
00:45:58,830 --> 00:46:01,220
Usted está utilizando la memoria mucho más de lo previsto

724
00:46:01,220 --> 00:46:03,960
todo a causa de un error estúpido en este caso,

725
00:46:03,960 --> 00:46:08,040
o en este caso una función muy deliberadamente hecho en sí de llamada.

726
00:46:08,040 --> 00:46:09,500
Ahora, esto no es del todo malo.

727
00:46:09,500 --> 00:46:13,800
Las funciones que se llaman en realidad tiene un gran poder cuando se lo usa correctamente.

728
00:46:13,800 --> 00:46:15,800
Yo no lo he usado correctamente aquí.

729
00:46:15,800 --> 00:46:19,780
Así que esto no es del todo malo, pero el hecho de que en realidad nunca me detengo llamando

730
00:46:19,780 --> 00:46:23,520
es una debilidad fundamental de este programa aquí.

731
00:46:23,520 --> 00:46:26,400
Entonces, ¿dónde vamos con todo esto? ¿Qué está pasando realmente?

732
00:46:26,400 --> 00:46:30,340
Cuando llamo a la función de incremento como si estuviéramos haciendo en estos ejemplos,

733
00:46:30,340 --> 00:46:33,420
Tengo un valor como una que yo paso pulg

734
00:46:33,420 --> 00:46:37,570
Me pasa una copia del número 1, por lo que sucede a continuación.

735
00:46:37,570 --> 00:46:44,240
Vamos a entrar en el incremento ejemplo, este tipo por aquí.

736
00:46:44,240 --> 00:46:46,870
Esto es lo que está sucediendo realmente.

737
00:46:46,870 --> 00:46:53,400
Cuando llamo incremento y paso en x, gráficamente, lo que está pasando aquí es lo siguiente.

738
00:46:53,400 --> 00:46:59,520
>> Si tengo el valor de 1 almacenan aquí y yo en realidad llamar incremento,

739
00:46:59,520 --> 00:47:04,330
que ahora se llama coro - el iPad me está echando de aquí.

740
00:47:04,330 --> 00:47:09,760
Vamos a llamar a este incremento, y no sabemos lo que esta función viene va a ser.

741
00:47:09,760 --> 00:47:14,840
Entonces, ¿qué está sucediendo realmente está aquí en alguna parte principal que tengo un trozo de memoria

742
00:47:14,840 --> 00:47:17,000
que almacena el número 1.

743
00:47:17,000 --> 00:47:19,380
Cuando llamo incremento, estoy usando otro trozo de la memoria,

744
00:47:19,380 --> 00:47:21,230
pero ahora tengo la copia de 1.

745
00:47:21,230 --> 00:47:26,660
Al aumentar este valor, este se convierte en 2,

746
00:47:26,660 --> 00:47:30,560
pero entonces lo que ocurre tan pronto como regresa de incremento?

747
00:47:30,560 --> 00:47:33,630
Esta memoria sólo se entregó de nuevo al sistema operativo,

748
00:47:33,630 --> 00:47:37,450
lo que significa que todo lo que hemos hecho es nada útil.

749
00:47:37,450 --> 00:47:43,120
El 1 que figuraba originalmente en el principal sigue siendo realmente allí.

750
00:47:43,120 --> 00:47:44,890
Entonces, ¿a dónde vamos con esto?

751
00:47:44,890 --> 00:47:49,770
Resulta que en la memoria que tiene esta secuencia de back-to-back de bytes

752
00:47:49,770 --> 00:47:53,050
que se pueden poner cosas adentro, y resulta que ya hemos visto algo

753
00:47:53,050 --> 00:47:55,390
que consiste en colocar las cosas vuelvan a espalda con espalda con espalda.

754
00:47:55,390 --> 00:47:59,860
¿Qué es una cadena basada en la semana 1 y la semana 2 ahora?

755
00:48:00,020 --> 00:48:01,980
Es sólo un conjunto de caracteres.

756
00:48:01,980 --> 00:48:04,310
Así que resulta tal como se puede poner los números en la memoria,

757
00:48:04,310 --> 00:48:06,990
Del mismo modo se puede poner caracteres en la memoria.

758
00:48:06,990 --> 00:48:10,530
Y una vez que empezamos a poner en la memoria de personajes de espaldas a la espalda con espalda,

759
00:48:10,530 --> 00:48:13,620
resulta que el uso de las cosas más simples como un bucle o un bucle while,

760
00:48:13,620 --> 00:48:17,170
podemos repetir de izquierda a derecha sobre los caracteres de una cadena

761
00:48:17,170 --> 00:48:20,600
y empezar a masajear en personajes completamente diferentes -

762
00:48:20,600 --> 00:48:23,370
podría convertirse en una b, b podría ser c -

763
00:48:23,370 --> 00:48:27,780
por lo que en última instancia, podemos tomar una frase Inglés que realmente tiene sentido

764
00:48:27,780 --> 00:48:30,310
y convertir cada una de estas una cartas en un momento

765
00:48:30,310 --> 00:48:34,400
caminando a través de la memoria de nuestro ordenador de izquierda a derecha para cifrar en realidad.

766
00:48:34,400 --> 00:48:35,810
Así que vamos a tener nuestros cinco minutos de descanso aquí,

767
00:48:35,810 --> 00:48:40,730
y cuando regresemos, vamos a empezar este proceso de codificación de la información.

768
00:48:42,020 --> 00:48:43,520
>> Está bien.

769
00:48:43,520 --> 00:48:48,070
Antes de sumergirse en alguna crypto y estas cosas llamadas matrices,

770
00:48:48,070 --> 00:48:51,470
permítanme hacer una pausa para cualquier pregunta, porque me siento como si realmente algo confusa

771
00:48:51,470 --> 00:48:54,080
algunos de esos temas. Así que vamos a arreglar ahora si podemos.

772
00:48:54,080 --> 00:48:58,700
Acabamos de hablar sobre valores de retorno, hablamos de argumentos,

773
00:48:58,700 --> 00:49:03,250
y hablamos de esta idea, que vamos a volver en las próximas semanas,

774
00:49:03,250 --> 00:49:08,720
de visualización de la memoria como un manojo entero de estas bandejas apiladas, por así decirlo,

775
00:49:08,720 --> 00:49:12,660
de abajo hacia arriba, de manera que cada bandeja que se ponen en la pila

776
00:49:12,660 --> 00:49:16,530
representa una función que está siendo llamado.

777
00:49:17,900 --> 00:49:20,260
¿Alguna pregunta?

778
00:49:20,260 --> 00:49:22,640
Permítame hacerle una pregunta aquí.

779
00:49:22,640 --> 00:49:27,890
Permítanme simplificar esto a lo que era antes de que algunos de nuestra anterior Q & A.

780
00:49:27,890 --> 00:49:35,570
El hecho de que el incremento tiene paréntesis de apertura, número int, cerrado paréntesis -

781
00:49:35,570 --> 00:49:39,110
¿qué número representa int?

782
00:49:39,110 --> 00:49:42,790
[Estudiante] Un argumento. >> Un argumento. Bien. Pero lo que es un argumento?

783
00:49:42,790 --> 00:49:46,370
[Respuesta de los estudiantes inaudible] >> ¿Qué es eso? >> [Estudiante] Algo que se pasa pulg

784
00:49:46,370 --> 00:49:49,940
Está bien, así que algo que se pasa pulg Y más en general, es sólo la entrada.

785
00:49:49,940 --> 00:49:52,450
Si estuviera escribiendo una función y propósito de tal función en la vida

786
00:49:52,450 --> 00:49:55,770
es hacer algo un poco diferente cada vez que lo utilice,

787
00:49:55,770 --> 00:50:00,110
entonces la única forma para que eso suceda realmente parece ser que le facilitara la entrada

788
00:50:00,110 --> 00:50:03,510
para que se pueda hacer algo diferente con esa entrada cada vez.

789
00:50:03,510 --> 00:50:06,650
>> Así que hay que especificar dos cosas cuando una función toma de entrada.

790
00:50:06,650 --> 00:50:09,590
Es necesario especificar el nombre que desea dar a esa entrada

791
00:50:09,590 --> 00:50:12,700
exclusivamente para su propia conveniencia, para que pueda referirse a ella

792
00:50:12,700 --> 00:50:16,540
en la función que usted está escribiendo, como lo hice aquí en la línea 32.

793
00:50:16,540 --> 00:50:20,800
Pero también hay que especificar su tipo, ya que C es un lenguaje de programación

794
00:50:20,800 --> 00:50:25,940
que sólo requiere que si quieres una variable, usted tiene que decirle a la computadora qué tipo de datos es,

795
00:50:25,940 --> 00:50:30,200
en gran parte, de manera que conozca el número de bits a asignar a esa variable

796
00:50:30,200 --> 00:50:33,020
porque podría ser de 6 - lo siento, no va a ser 6.

797
00:50:33,020 --> 00:50:37,080
Puede ser 16, puede ser 8, puede ser 32, incluso 64,

798
00:50:37,080 --> 00:50:39,130
pero el equipo tiene que saber.

799
00:50:39,130 --> 00:50:43,180
Ahora, la INT en el lado izquierdo representa lo que, por el contrario?

800
00:50:46,350 --> 00:50:48,850
[Respuesta de los estudiantes inaudible] >> ¿Qué es eso? >> [Estudiante] Tipo de función.

801
00:50:48,850 --> 00:50:53,610
El tipo de una función y, más específicamente, el tipo de su producción. Derecha.

802
00:50:53,610 --> 00:50:57,380
Así, mientras que la cosa en paréntesis representa su entrada, en su caso,

803
00:50:57,380 --> 00:50:59,660
la cosa a la izquierda representa la salida.

804
00:50:59,660 --> 00:51:03,530
Y en este caso, el incremento aparentemente devuelve un int,

805
00:51:03,530 --> 00:51:07,690
y así int es el tipo de retorno de esta función.

806
00:51:07,690 --> 00:51:09,340
¿Qué significa regresar?

807
00:51:09,340 --> 00:51:15,090
Literalmente, se utiliza la palabra clave return y luego, si lo va a devolver

808
00:51:15,090 --> 00:51:18,600
a la derecha de la palabra clave es un número entero,

809
00:51:18,600 --> 00:51:21,660
entonces que es consistente con lo que hemos prometido.

810
00:51:21,660 --> 00:51:26,410
No se podría hacer algo como esto - hola, mundo - porque eso es una cadena.

811
00:51:26,410 --> 00:51:28,860
>> Obviamente, no es un número entero.

812
00:51:28,860 --> 00:51:33,140
Así que en resumen, la carga está realmente en nosotros, el programador, para ser específico

813
00:51:33,140 --> 00:51:37,770
en cuanto a lo que estamos regresando y para entonces que seguir para devolverlo.

814
00:51:37,770 --> 00:51:43,440
El contexto aquí es que la memoria de su computadora es un gigabyte, 2 gigabytes -

815
00:51:43,440 --> 00:51:45,920
lo que sea - tal vez es más, tal vez es menos,

816
00:51:45,920 --> 00:51:49,050
pero el equipo que considera que tiene diferentes secciones.

817
00:51:49,050 --> 00:51:51,200
Algo pasa ahí abajo, algo más va allá arriba,

818
00:51:51,200 --> 00:51:54,290
cosas diferentes va en el medio, y hoy simplemente comenzar a contar la historia,

819
00:51:54,290 --> 00:51:56,340
pero vamos a volver a este momento de nuevo.

820
00:51:56,340 --> 00:51:59,980
Por ahora, la única memoria que realmente importa es el segmento de texto

821
00:51:59,980 --> 00:52:03,360
ya que sólo representa el 0 y 1 que Clang se emiten.

822
00:52:03,360 --> 00:52:06,050
Así que cuando se ejecuta un comando en el teclado como a.out

823
00:52:06,050 --> 00:52:09,110
o hace doble clic en un icono en Mac OS o Windows,

824
00:52:09,110 --> 00:52:11,880
el programa se carga desde el disco duro a la RAM

825
00:52:11,880 --> 00:52:16,330
y se dejó caer en la cima de la memoria RAM del ordenador, por así decirlo.

826
00:52:16,330 --> 00:52:20,450
Mientras tanto, comienza tu programa de entrenamiento y principal llamada se

827
00:52:20,450 --> 00:52:23,640
en el programa que escribió o escribe el programa de Microsoft o Apple,

828
00:52:23,640 --> 00:52:27,860
cualquiera de sus variables locales terminan ahí abajo en la parte inferior de la memoria de su computadora.

829
00:52:27,860 --> 00:52:33,230
Pero si las llamadas principales a otra función que se tiene variables o argumentos, terminan encima de ella.

830
00:52:33,230 --> 00:52:36,680
Y si esa función llama a algo, terminan encima de él, encima de él, encima de él.

831
00:52:36,680 --> 00:52:41,460
>> Y sólo una vez una función se hace ejecutar es la pila de bandejas, por así decirlo,

832
00:52:41,460 --> 00:52:43,240
comienzan a ponerse más y más.

833
00:52:43,240 --> 00:52:48,250
Y esto es lo que entonces, en pocas palabras, explica por qué cuando se llama cubo

834
00:52:48,250 --> 00:52:51,550
o puede llamar al incremento, que está pasando por una copia del valor.

835
00:52:51,550 --> 00:52:55,520
Y lo que eso significa es que pictóricamente está literalmente escrito el número 1

836
00:52:55,520 --> 00:53:00,460
en otra parte de la memoria, el cambio de que 1 a 2 en el caso de incremento

837
00:53:00,460 --> 00:53:04,820
o a un 8 en el caso de cubo y luego tirar de que la memoria de distancia

838
00:53:04,820 --> 00:53:09,140
tan pronto como el incremento de los rendimientos o de funciones de cubo. Pregunta.

839
00:53:09,140 --> 00:53:12,900
[Estudiante] ¿Dónde se almacenan las variables globales?

840
00:53:12,900 --> 00:53:18,100
Las variables globales se almacenan en lo que se llama actualmente los datos inicializados o datos sin inicializar,

841
00:53:18,100 --> 00:53:21,920
la diferencia está en si tiene una variable global y se le asigna un valor inmediato

842
00:53:21,920 --> 00:53:24,640
con el signo de igualdad, termina en la parte superior hay,

843
00:53:24,640 --> 00:53:29,200
y si lo que dicen int x; sin valor, termina ligeramente inferior en RAM

844
00:53:29,200 --> 00:53:31,710
simplemente por convención.

845
00:53:31,710 --> 00:53:34,940
Otras preguntas? Está bien.

846
00:53:34,940 --> 00:53:37,340
Así que esta imagen regresará a medida que más poderoso

847
00:53:37,340 --> 00:53:39,170
con lo que podemos hacer con el ordenador,

848
00:53:39,170 --> 00:53:42,720
pero por ahora, vamos a tener una breve introducción a la criptografía,

849
00:53:42,720 --> 00:53:46,080
un tipo específico de criptografía que no resuelve todos los problemas del mundo

850
00:53:46,080 --> 00:53:47,720
pero es resolver algunos de ellos.

851
00:53:47,720 --> 00:53:51,700
En este caso aquí, tenemos algo que se llama criptografía de clave secreta.

852
00:53:51,700 --> 00:53:56,410
Criptografía de clave secreta, como el nombre sugiere, deriva su seguridad de un secreto.

853
00:53:56,410 --> 00:54:00,690
>> Por ejemplo, si estaban de vuelta en la escuela primaria y que estaban pasando una carta secreta poco de amor

854
00:54:00,690 --> 00:54:04,850
para el chico o la chica con la que estaban aplastando en adelante, si quería pasar esa nota a través de la audiencia,

855
00:54:04,850 --> 00:54:08,380
es probable que no iba a escribir una nota en Inglés o lo que su lengua materna es.

856
00:54:08,380 --> 00:54:13,340
Más bien, es posible cifrar o simplemente puede enviarles un mensaje de texto en estos días.

857
00:54:13,340 --> 00:54:15,460
Pero que en realidad podría pasar una nota a través de la sala de clase.

858
00:54:15,460 --> 00:54:18,700
Y para hacerlo con seguridad, de tal manera que sus amigos y el profesor

859
00:54:18,700 --> 00:54:22,650
no sabes lo que estás escribiendo, es posible llegar a un algoritmo bastante simple,

860
00:54:22,650 --> 00:54:25,920
joven, aunque es posible que, con sólo mezclar las palabras.

861
00:54:25,920 --> 00:54:28,130
Así que en lugar de escribir una puede escribir b,

862
00:54:28,130 --> 00:54:30,220
en lugar de b puede escribir c,

863
00:54:30,220 --> 00:54:32,140
en vez de c puede escribir d, y así sucesivamente.

864
00:54:32,140 --> 00:54:34,360
O bien, podría llegar a una traducción más sofisticada

865
00:54:34,360 --> 00:54:36,720
de cartas a diferentes letras.

866
00:54:36,720 --> 00:54:39,740
Pero el problema es el chico o la chica a la que le está enviando esta nota

867
00:54:39,740 --> 00:54:45,020
tiene que saber algo, que es lo que, obviamente? >> [Estudiante] Lo que usted está enviando.

868
00:54:45,020 --> 00:54:49,720
¿Cuál es su secreto, como lo es que la asignación entre una y la de B y de C y D's.

869
00:54:49,720 --> 00:54:54,650
¿Es sólo la adición de 1 a cada una de las letras para ir de A a B, de B a C?

870
00:54:54,650 --> 00:54:56,670
¿Es más complejo que eso?

871
00:54:56,670 --> 00:55:01,540
>> Así que tú y tu enamorado es necesario tener esta información secreta,

872
00:55:01,540 --> 00:55:03,190
pero hay una especie de catch-22 aquí.

873
00:55:03,190 --> 00:55:06,830
Si esta es la primera vez que va a enviar esta carta de amor a través de la clase,

874
00:55:06,830 --> 00:55:10,720
¿cómo es ese niño o niña va a saber cuál es el secreto incluso es?

875
00:55:10,720 --> 00:55:13,930
Así clave secreta de cifrado no resuelve todos los problemas del mundo,

876
00:55:13,930 --> 00:55:16,320
y de hecho hay una relación que aquí vamos a volver a hacia el final del semestre.

877
00:55:16,320 --> 00:55:25,110
Del mismo modo, no la mayoría de nosotros conoce a alguien que trabaja, por ejemplo, en Amazon.com,

878
00:55:25,110 --> 00:55:28,190
y sin embargo, muchos de nosotros hemos comprado cosas en Amazon.com,

879
00:55:28,190 --> 00:55:31,990
y se nos ha enseñado a asumir que estas transacciones de comercio electrónico son seguros.

880
00:55:31,990 --> 00:55:36,470
La dirección URL https probablemente dice, hay tal vez un icono de candado poco tonto en alguna parte,

881
00:55:36,470 --> 00:55:39,930
hay una especie de criptografía asegurar su información de tarjeta de crédito

882
00:55:39,930 --> 00:55:42,160
entre usted y Amazon.com.

883
00:55:42,160 --> 00:55:45,430
Y sin embargo, si la criptografía implica saber algún secreto

884
00:55:45,430 --> 00:55:48,620
y sin embargo, yo no conozco a nadie en Amazon y no he arreglado sin duda algún tipo de secreto

885
00:55:48,620 --> 00:55:52,710
con alguien en el Amazonas, ¿cómo es mi ordenador o mi navegador haciendo esto?

886
00:55:52,710 --> 00:55:55,720
Resulta que hay otros tipos de criptografía en conjunto que resolver ese problema.

887
00:55:55,720 --> 00:55:57,670
Pero por hoy, nos centraremos en el sencillo

888
00:55:57,670 --> 00:56:00,290
donde se puede organizar con antelación para conocer algún secreto

889
00:56:00,290 --> 00:56:03,760
como una u otra asignación entre una y la de b.

890
00:56:03,760 --> 00:56:05,840
Y el proceso de criptografía generalmente implica esto.

891
00:56:05,840 --> 00:56:08,620
Usted tiene un poco de texto sin formato, representado aquí a la izquierda,

892
00:56:08,620 --> 00:56:12,930
se ejecuta a través de algún tipo de algoritmo o procedimiento para cifrarlo -

893
00:56:12,930 --> 00:56:15,100
tal vez eso es sólo una se convierte en b, b se convierte en c -

894
00:56:15,100 --> 00:56:17,490
y entonces termina con texto cifrado.

895
00:56:17,490 --> 00:56:20,380
Mientras tanto, una vez que su enamoramiento recibe esta nota secreta,

896
00:56:20,380 --> 00:56:24,200
él o ella tiene que descífralo por lo general revertir ese algoritmo

897
00:56:24,200 --> 00:56:27,190
con el fin de recuperar el texto sin formato.

898
00:56:27,190 --> 00:56:28,960
Hay encarnaciones físicas de este.

899
00:56:28,960 --> 00:56:31,680
>> Por ejemplo, este es un anillo decodificador secreto poco,

900
00:56:31,680 --> 00:56:35,110
y este es un anillo en el sentido de que hay dos diales aquí.

901
00:56:35,110 --> 00:56:38,490
En la periferia exterior de esta cosa, no hay letras de la A a la Z,

902
00:56:38,490 --> 00:56:40,340
aunque están en orden aleatorio,

903
00:56:40,340 --> 00:56:42,880
y en el interior, de hecho hay algunos números

904
00:56:42,880 --> 00:56:46,620
de tal manera que con este anillo te pueden especie de vuelta al exterior pero no el interior

905
00:56:46,620 --> 00:56:49,140
con el fin de alinear los números con letras.

906
00:56:49,140 --> 00:56:53,020
A partir de una película que se llama Un cuento de Navidad, verás que poco Ralphie

907
00:56:53,020 --> 00:56:58,000
estaba tan ansioso de averiguar cuál es el mensaje secreto Little Orphan Annie era para él

908
00:56:58,000 --> 00:57:02,570
que había sido comunicada, creo, en forma de mensajes numéricos en una caja de cereal

909
00:57:02,570 --> 00:57:07,220
y ha tenido que acumular todas las pequeñas tarjetas que vienen en la caja de cereal,

910
00:57:07,220 --> 00:57:09,770
había que enviarlos por correo, había que recuperar el anillo decodificador secreto

911
00:57:09,770 --> 00:57:13,910
de modo que usted puede finalmente entender lo que el mapeo es entre las letras y los números

912
00:57:13,910 --> 00:57:15,550
o letras y letras.

913
00:57:15,550 --> 00:57:19,520
¿Cómo en un ordenador podemos ir sobre la aplicación o representar las cosas de esta manera?

914
00:57:19,520 --> 00:57:22,560
Necesitamos una manera de expresarnos un poco más flexible

915
00:57:22,560 --> 00:57:25,080
que nuestras variables hasta el momento han permitido.

916
00:57:25,080 --> 00:57:29,000
Hemos tenido enteros, hemos tenido caracteres, hemos tenido flotadores y dobles y algunos otros,

917
00:57:29,000 --> 00:57:34,200
pero esas son las piezas individuales de la memoria que realmente no nos permiten expresar cosas

918
00:57:34,200 --> 00:57:36,440
como las palabras y las oraciones y frases.

919
00:57:36,440 --> 00:57:38,630
De hecho, hemos llamado cuerdas esas cosas,

920
00:57:38,630 --> 00:57:42,660
pero prometo que esto es sólo una simplificación en la biblioteca CS50

921
00:57:42,660 --> 00:57:45,540
que estamos intentando pelar.

922
00:57:45,540 --> 00:57:47,500
Así que vamos a empezar a hacer eso aquí.

923
00:57:47,500 --> 00:57:49,840
Déjenme seguir adelante y abrir un archivo -

924
00:57:49,840 --> 00:57:54,100
todos estos archivos están disponibles, como de costumbre, en línea - array.c llamada

925
00:57:54,100 --> 00:57:58,960
para resolver un problema no relacionado con las cadenas, pero que pinta un cuadro aquí

926
00:57:58,960 --> 00:58:01,520
de cómo podríamos usar algo que se llama una matriz.

927
00:58:01,520 --> 00:58:04,050
>> Una matriz es un tipo de datos.

928
00:58:04,050 --> 00:58:10,730
Es un tipo de variable de tipo que tiene varios tipos de datos más pequeñas dentro de ella

929
00:58:10,730 --> 00:58:12,680
espalda con espalda a espalda con espalda.

930
00:58:12,680 --> 00:58:16,980
Así, por ejemplo, si queremos escribir un pequeño programa que te da el promedio de concurso

931
00:58:16,980 --> 00:58:19,780
para un curso como 50 que tiene dos cuestionarios,

932
00:58:19,780 --> 00:58:23,450
que podría muy fácilmente escribir este programa basado incluso en algunos de los materiales de la semana pasada

933
00:58:23,450 --> 00:58:28,830
mediante el uso de getInt y un par de variables: int quiz1, int quiz2.

934
00:58:28,830 --> 00:58:30,550
Y es bastante sencillo.

935
00:58:30,550 --> 00:58:33,500
Es tal vez 10, 20 líneas de código máximo para poner en práctica un programa de

936
00:58:33,500 --> 00:58:38,940
que pide al usuario 2 puntuaciones prueba y luego calcula su promedio

937
00:58:38,940 --> 00:58:42,020
mediante la adición de ellos juntos, dividiendo por 2, y luego imprimir los resultados.

938
00:58:42,020 --> 00:58:46,400
Probablemente podríamos hacer eso muy fácilmente ahora, después de un cierto número de minutos.

939
00:58:46,400 --> 00:58:49,450
Pero el problema es que suponer que 50 tenían 3 o 4 pruebas.

940
00:58:49,450 --> 00:58:52,830
Supongamos que usted quisiera utilizar el mismo programa para una clase que tenía pruebas semanales.

941
00:58:52,830 --> 00:58:55,100
Piense en una clase que ha exámenes semanales.

942
00:58:55,100 --> 00:58:58,840
Si hay 16 o más semanas en un semestre, ahora tiene 16 variables:

943
00:58:58,840 --> 00:59:03,030
quiz1 int, int quiz2, int quiz3, int quiz4.

944
00:59:03,030 --> 00:59:06,870
Tan pronto como usted comienza a ver esta redundancia, esta copiando y pegando el código,

945
00:59:06,870 --> 00:59:09,810
debe comenzar a hacer que te gustaría que hubiera una manera mejor.

946
00:59:09,810 --> 00:59:13,610
Y gracias a Dios, a causa de las matrices que hay. Así que vamos a hacer esto.

947
00:59:13,610 --> 00:59:16,700
En primer lugar, permítanme presentarles a una cosa muy simple que no hemos usado hasta ahora,

948
00:59:16,700 --> 00:59:18,820
pero lo vas a ver de vez en cuando en el código.

949
00:59:18,820 --> 00:59:21,270
>> Esto es lo que generalmente se llama una constante.

950
00:59:21,270 --> 00:59:24,410
Así que es una constante en el sentido de que este valor nunca cambia.

951
00:59:24,410 --> 00:59:26,450
La convención humana cuando se crea una constante

952
00:59:26,450 --> 00:59:30,420
es el uso de letras mayúsculas sólo para que realmente se destaca en su código,

953
00:59:30,420 --> 00:59:34,270
y la palabra clave especial que se utiliza en C # define.

954
00:59:34,270 --> 00:59:39,970
Por eso decimos # define, luego un espacio, entonces la palabra que desea utilizar para el nombre de la constante de

955
00:59:39,970 --> 00:59:41,730
y luego el valor de la constante.

956
00:59:41,730 --> 00:59:44,710
Tenga en cuenta que esto es diferente de asigna algo a una variable.

957
00:59:44,710 --> 00:59:46,430
No hay ningún signo igual, no hay punto y coma.

958
00:59:46,430 --> 00:59:49,140
Esto es lo que se conoce generalmente como una directiva de preprocesador,

959
00:59:49,140 --> 00:59:50,840
pero más de eso en otro momento.

960
00:59:50,840 --> 00:59:56,350
Por ahora, esto crea un valor inmutable llamado TESTS

961
00:59:56,350 --> 00:59:58,290
cuyo valor numérico real es 2.

962
00:59:58,290 --> 01:00:02,180
Así que donde quiera que vea pruebas, exámenes, pruebas cortas a lo largo de este archivo,

963
01:00:02,180 --> 01:00:04,230
eso es sólo el número 2.

964
01:00:04,230 --> 01:00:06,550
Si miro principal ahora, vamos a ver cómo funciona esto.

965
01:00:06,550 --> 01:00:09,770
Primero se ve un poco críptico, pero es todo cosas de la semana 1.

966
01:00:09,770 --> 01:00:12,210
Pida al usuario para los grados. ¿Cómo podemos hacer esto?

967
01:00:12,210 --> 01:00:17,350
En la línea 22 - esta es realmente la parte jugosa - Declaro un flotador

968
01:00:17,350 --> 01:00:23,240
pero no es sólo un solo flotador. Estoy declarando, más bien, un conjunto de valores de punto flotante.

969
01:00:23,240 --> 01:00:27,700
Esa variable se va a llamar grados, como se implica aquí,

970
01:00:27,700 --> 01:00:31,420
pero la única nueva sintaxis entonces son estos corchetes.

971
01:00:31,420 --> 01:00:37,280
El hecho de que lo que he dicho grados flotador y luego abrir el paréntesis y luego el número a -

972
01:00:37,280 --> 01:00:40,980
cuenta si se trata de una constante es igual que lo hicimos -

973
01:00:40,980 --> 01:00:46,840
esto quiere decir, "Hey ordenador, déme 2 flotadores y vamos a llamarlos colectivamente grados".

974
01:00:46,840 --> 01:00:51,780
>> Esto está en contraste con un proceso mucho más tedioso así: flotador grado 1;

975
01:00:51,780 --> 01:00:54,580
grade2 flotar, y así sucesivamente.

976
01:00:54,580 --> 01:00:58,310
Así que una matriz que nos permite poner en práctica esta idea, pero mucho menos desordenadamente,

977
01:00:58,310 --> 01:01:04,560
de tal manera que podemos escribir una línea de código en lugar de, por ejemplo, 16 para un semestre de 16 semanas.

978
01:01:04,560 --> 01:01:09,060
Yo no quería que codificar 2 porque si se piensa en esto ahora, lógicamente,

979
01:01:09,060 --> 01:01:12,560
Supongo que el año que viene CS50 cambios a 3 cuestionarios en lugar

980
01:01:12,560 --> 01:01:15,010
y yo tenía el número 2 aquí, yo tenía el número 2 aquí,

981
01:01:15,010 --> 01:01:17,210
Yo tenía el número 2 aquí, el número 2 aquí.

982
01:01:17,210 --> 01:01:19,890
Se vuelve muy tedioso y muy fácil meter la pata

983
01:01:19,890 --> 01:01:26,550
y cambiar accidentalmente un valor a 3 y se pierda algún otro valor de 2.

984
01:01:26,550 --> 01:01:30,660
Así que voy a este lugar abstracto lejos y utilizar esta constante que,

985
01:01:30,660 --> 01:01:32,520
Como su nombre indica, nunca cambia.

986
01:01:32,520 --> 01:01:35,870
Y ahora no importa si tenemos diferentes concursos de este año o el próximo,

987
01:01:35,870 --> 01:01:39,380
Sólo tengo que cambiarlo en un lugar aquí en la parte superior.

988
01:01:39,380 --> 01:01:41,230
Así que eso es todo, una constante es.

989
01:01:41,230 --> 01:01:47,100
Mientras tanto, la característica nueva es que conceptual de una matriz.

990
01:01:47,100 --> 01:01:55,030
Así que los corchetes darme esta flota y muchos me permite llamarlos colectivamente grados aquí.

991
01:01:55,030 --> 01:01:56,720
Así que ahora vamos a ver lo que voy a hacer.

992
01:01:56,720 --> 01:01:59,220
Aquí, en la línea 24 es el inicio de un bucle.

993
01:01:59,220 --> 01:02:03,380
>> Esto es realmente nada especial. Es sólo mediante TESTS lugar de un número codificado.

994
01:02:03,380 --> 01:02:06,740
Pero no hay nada intelectualmente diferente allí la semana pasada.

995
01:02:06,740 --> 01:02:11,650
Esto es sólo printf, así printf ("Quiz #% d de% d:")

996
01:02:11,650 --> 01:02:16,670
porque sólo quiero imprimir dame concurso número 1 de 2 y luego 2 de 2.

997
01:02:16,670 --> 01:02:18,480
Así que esto es algo puramente estético.

998
01:02:18,480 --> 01:02:21,000
Pero la parte más interesante ahora está en la línea 27.

999
01:02:21,000 --> 01:02:27,840
A fin de llenar en uno de los dos marcadores de posición con un valor de punto flotante,

1000
01:02:27,840 --> 01:02:29,640
de nuevo utilizar corchetes.

1001
01:02:29,640 --> 01:02:35,170
En este caso, estoy usando i porque este bucle for se ha iniciado con i igualando el valor que, al parecer?

1002
01:02:35,170 --> 01:02:36,670
[Estudiante] 0. >> [Malan] 0.

1003
01:02:36,670 --> 01:02:40,990
Así que en la primera iteración de este bucle, es como si yo escribí esto en el código,

1004
01:02:40,990 --> 01:02:46,310
pero en la segunda iteración de este bucle, es como si yo escribí esto en mi código.

1005
01:02:46,310 --> 01:02:49,970
Pero el hecho de que yo estoy usando una variable es perfecto porque, como su nombre lo indica,

1006
01:02:49,970 --> 01:02:52,600
está variando su valor en cada iteración,

1007
01:02:52,600 --> 01:02:55,900
así que estoy llenando esta matriz un lugar a la vez.

1008
01:02:55,900 --> 01:02:57,380
¿Qué hace este arreglo parece?

1009
01:02:57,380 --> 01:03:01,570
La razón por la que dibujó el cuadrado super simple en la pantalla de aquí antes de que fue por esta razón.

1010
01:03:01,570 --> 01:03:05,590
Una matriz es simplemente un trozo de memoria seguido de otro trozo de memoria

1011
01:03:05,590 --> 01:03:08,570
seguido por otro bloque de memoria y así sucesivamente.

1012
01:03:08,570 --> 01:03:13,120
Así que si mi matriz es de tamaño 2 en este caso aquí, lo único que estaría haciendo

1013
01:03:13,120 --> 01:03:20,200
escribiendo en las puntuaciones de mis concursos como aquí - Tengo 100 en éste y luego me dieron un 99 en este caso -

1014
01:03:20,200 --> 01:03:24,970
entonces esta memoria que ni siquiera puede utilizar porque sólo he pedido al equipo

1015
01:03:24,970 --> 01:03:26,840
para una matriz de tamaño 2.

1016
01:03:26,840 --> 01:03:28,600
Las plazas están todavía allí, ¿verdad?

1017
01:03:28,600 --> 01:03:32,670
Aún dispone de 2 gigabytes de RAM, incluso si sólo está solicitando para 2 carros.

1018
01:03:32,670 --> 01:03:36,840
Así que la idea detrás de las matrices es que la computadora sólo toma un trozo de memoria

1019
01:03:36,840 --> 01:03:41,340
y luego reparte trozos más pequeños de espaldas a la espalda con espalda.

1020
01:03:41,340 --> 01:03:43,310
Y eso es todo un arreglo es.

1021
01:03:43,310 --> 01:03:47,350
>> Es un trozo contiguo de memoria dentro de la cual usted puede poner las cosas.

1022
01:03:47,350 --> 01:03:50,700
Esto le pasa a hacer a continuación, sólo un poco de aritmética aburrido.

1023
01:03:50,700 --> 01:03:54,640
Si me desplazo hasta aquí, aquí es donde me iterar sobre la matriz.

1024
01:03:54,640 --> 01:03:58,020
Vengo con la suma de todos los valores de la matriz,

1025
01:03:58,020 --> 01:04:02,470
y luego usar la función round aquí para hacer realidad la suma dividida por Quizzes.

1026
01:04:02,470 --> 01:04:06,320
Pero permítanme saludar a mi mano que como una especie de aritmética suficiente por ahora.

1027
01:04:06,320 --> 01:04:08,370
Pero todo lo que está haciendo por mí en última instancia está calculando un promedio.

1028
01:04:08,370 --> 01:04:13,580
Así que prueba primero más segundo cuestionario dividido por 2 y luego imprimirlos como un int.

1029
01:04:13,580 --> 01:04:17,280
Pero ahora vamos a la transición a un ejemplo diferente llamado cadena1,

1030
01:04:17,280 --> 01:04:20,700
que pinta un cuadro similar pero utilizando cuerdas.

1031
01:04:20,700 --> 01:04:23,940
Déjenme seguir adelante y simplificar esto por un momento.

1032
01:04:23,940 --> 01:04:27,090
Perdona la sangría por ahora.

1033
01:04:27,090 --> 01:04:30,870
Observe en la línea 19 de este ejemplo, tengo una cadena del usuario.

1034
01:04:30,870 --> 01:04:34,640
Pero note lo que estoy haciendo en la siguiente líneas 22 en adelante.

1035
01:04:34,640 --> 01:04:41,250
En realidad estoy iterar desde i hasta - y este es un nuevo truco - strlen, longitud de la cadena.

1036
01:04:41,250 --> 01:04:44,880
Esta es una función que viene con C que si se le pasa una cadena,

1037
01:04:44,880 --> 01:04:47,730
te dice cuántos caracteres hay en esa cadena. Eso es todo.

1038
01:04:47,730 --> 01:04:51,550
Y el hecho de que es strlen en lugar de la longitud de la cadena es sólo porque es más conciso.

1039
01:04:51,550 --> 01:04:55,100
Treinta años atrás, la gente le gusta escribir cosas lo más sucintamente posible,

1040
01:04:55,100 --> 01:04:57,630
así que hemos mantenido esa convención aquí.

1041
01:04:57,630 --> 01:05:00,660
i + + sólo significa incrementar i en cada iteración.

1042
01:05:00,660 --> 01:05:02,990
Y ahora noten esto, que es muy interesante.

1043
01:05:02,990 --> 01:05:09,180
En la línea 24, le digo, "Ordenador, dame un personaje, 8 bits, y lo llaman c".

1044
01:05:09,180 --> 01:05:12,630
¿Pero qué es esto en la parte derecha diciendo?

1045
01:05:13,490 --> 01:05:16,530
En Inglés, ¿qué representa?

1046
01:05:16,530 --> 01:05:18,730
[Estudiante] El primer carácter del conjunto.

1047
01:05:18,730 --> 01:05:20,790
Exactamente. Dame el primer carácter de la matriz.

1048
01:05:20,790 --> 01:05:24,090
O, más en general, me dan el carácter i en la matriz.

1049
01:05:24,090 --> 01:05:26,100
Y darse cuenta de que es importante ahora que como los informáticos,

1050
01:05:26,100 --> 01:05:27,890
en realidad estamos contando desde 0.

1051
01:05:27,890 --> 01:05:29,720
>> Usted no tiene la discreción para empezar a hacerlo.

1052
01:05:29,720 --> 01:05:34,160
Ahora usted tiene que comportarse de acuerdo con las expectativas del equipo y contar de 0

1053
01:05:34,160 --> 01:05:38,180
porque [0] va a ser el primer carácter de una cadena,

1054
01:05:38,180 --> 01:05:42,150
[1] va a ser la segunda, [2] que va a ser el tercero, y así sucesivamente.

1055
01:05:42,150 --> 01:05:49,720
Así que este programa, si lo compila, se trata nuevamente de cadena1, así que cadena1,

1056
01:05:49,720 --> 01:05:54,670
y ahora me he encontrado en mi cadena1 ventana de terminal.

1057
01:05:54,670 --> 01:05:58,330
Se espera para la entrada, así que voy a escribir en David, Enter,

1058
01:05:58,330 --> 01:06:02,540
y ahora imprime David todo en líneas diferentes, porque fíjate lo que estoy haciendo.

1059
01:06:02,540 --> 01:06:05,820
Estoy imprimiendo un carácter a la vez.

1060
01:06:05,820 --> 01:06:10,100
No vamos a entrar en detalles hoy sobre esto, pero he eliminado hace un momento este cheque aquí.

1061
01:06:10,100 --> 01:06:15,480
Resulta que si el usuario se está portando mal, contradictorio, confuso o simplemente

1062
01:06:15,480 --> 01:06:20,210
en realidad se puede dejar de dar una serie de cierta extensión.

1063
01:06:20,210 --> 01:06:22,860
Si se pulsa la tecla equivocada en el teclado, se puede dar ninguna cadena en absoluto,

1064
01:06:22,860 --> 01:06:26,950
o si usted es malicioso, puede intentar para pegar en el patrimonio de un gigabyte de un ensayo

1065
01:06:26,950 --> 01:06:29,290
para llenar esta cadena, y si el equipo se queda sin memoria,

1066
01:06:29,290 --> 01:06:32,710
resulta que vamos a volver este valor especial llamado NULL.

1067
01:06:32,710 --> 01:06:35,580
Así que por ahora, sólo sé que hay este valor especial llamado NULL

1068
01:06:35,580 --> 01:06:39,580
que nos permitirá comprobar cuando estamos fuera de la memoria, entre otras cosas.

1069
01:06:39,580 --> 01:06:45,630
Pero si abro ahora cadena2, note una diferencia aquí.

1070
01:06:45,630 --> 01:06:48,210
Tenga en cuenta una diferencia aquí con cadena2.

1071
01:06:48,210 --> 01:06:51,340
Con cadena2, este bucle for es un poco diferente.

1072
01:06:51,340 --> 01:06:55,010
>> Déjame borrar los valores NULL para que podamos hablar de aquellos en otro momento.

1073
01:06:55,010 --> 01:06:57,800
¿Qué hay de diferente en el bucle for esta vez?

1074
01:06:59,620 --> 01:07:01,670
Puedo volver al ejemplo anterior.

1075
01:07:01,670 --> 01:07:08,580
Así que es la versión 2, esta es la versión 1. 1, 2.

1076
01:07:08,580 --> 01:07:11,980
1, 2.

1077
01:07:13,520 --> 01:07:16,660
La llamada strlen es ¿dónde?

1078
01:07:16,660 --> 01:07:18,860
Está en la primera parte del bucle for.

1079
01:07:18,860 --> 01:07:21,830
¿Alguna idea de por qué estoy haciendo esto? Si.

1080
01:07:21,830 --> 01:07:24,560
[Estudiante] Así no se llama a la función cada vez.

1081
01:07:24,560 --> 01:07:26,440
[Malan] Así que no llame a la función cada vez. Exactamente.

1082
01:07:26,440 --> 01:07:28,300
Recuerde que en los bucles for que son super simple

1083
01:07:28,300 --> 01:07:31,770
una vez que una especie de comprender que esta es la inicialización, la condición, y la actualización.

1084
01:07:31,770 --> 01:07:34,750
El problema es que la condición ocurre en cada iteración del bucle.

1085
01:07:34,750 --> 01:07:40,010
Y así, en este ejemplo aquí, ¿qué tiene de malo el hecho de que esta es mi condición?

1086
01:07:40,010 --> 01:07:41,830
[Estudiante] Estás llamando strlen.

1087
01:07:41,830 --> 01:07:44,340
[Malan] Estás llamando strlen una y otra vez y otra vez.

1088
01:07:44,340 --> 01:07:47,410
Pero una vez que has escrito en David, la longitud de la cadena es de 5,

1089
01:07:47,410 --> 01:07:49,650
y eso no va a cambiar en cada iteración del bucle

1090
01:07:49,650 --> 01:07:51,670
porque la cadena es aún D-A-v-i-d.

1091
01:07:51,670 --> 01:07:55,320
Así que esta es una pista de lo que va a convertirse en una idea cada vez más importante

1092
01:07:55,320 --> 01:08:00,410
conocida como una decisión de diseño donde simplemente no hacer que el ordenador haga el trabajo innecesario.

1093
01:08:00,410 --> 01:08:03,920
>> Así como un anticipo de pset2, pset2 en la edición estándar

1094
01:08:03,920 --> 01:08:07,030
te va a desafiar a aplicar en la práctica un cierto número de cifras,

1095
01:08:07,030 --> 01:08:10,410
un número de algoritmos de cifrado, por lo que ambos puedan cifrar

1096
01:08:10,410 --> 01:08:13,840
y descifrar mensajes secretos muy similar a la Ralphie hay un decodificado.

1097
01:08:13,840 --> 01:08:16,810
En la edición pirata de pset2, vamos a ir un poco más lejos.

1098
01:08:16,810 --> 01:08:19,649
Nos vamos a entregar un archivo de un sistema informático actual

1099
01:08:19,649 --> 01:08:23,479
que contiene una gran cantidad de nombres de usuario y contraseñas cifradas reales,

1100
01:08:23,479 --> 01:08:26,939
y el reto de la edición pirata va a ser para agrietar las contraseñas

1101
01:08:26,939 --> 01:08:33,200
y averiguar lo que la criptografía o qué secreto se utilizó para generar realmente las contraseñas.

1102
01:08:33,200 --> 01:08:36,109
Y vamos a hacer esto utilizando una nueva característica de C

1103
01:08:36,109 --> 01:08:40,630
que te voy a dar sólo un demo del conocido como argumentos de línea de comandos.

1104
01:08:40,630 --> 01:08:44,229
Resulta que, como algunos de ustedes pueden haber visto en la sección o en libros de texto,

1105
01:08:44,229 --> 01:08:48,260
principal no tiene que siempre ser nulo entre paréntesis.

1106
01:08:48,260 --> 01:08:52,430
Resulta que la principal también se puede escribir así, con dos argumentos,

1107
01:08:52,430 --> 01:08:56,870
argc y argv, donde argc es el número de palabras

1108
01:08:56,870 --> 01:09:00,020
que se escribe después del nombre del programa en la línea de comandos

1109
01:09:00,020 --> 01:09:03,420
y argv son las palabras reales.

1110
01:09:03,420 --> 01:09:07,540
Y como los corchetes indican allí, argv es aparentemente una matriz.

1111
01:09:07,540 --> 01:09:12,210
Va a ser una cadena después de una serie después de una cadena en la memoria.

1112
01:09:12,210 --> 01:09:16,010
>> Entonces, ¿qué vamos a ser capaces de hacer a partir de conjunto de procesadores 2 es algo como esto.

1113
01:09:16,010 --> 01:09:21,350
Si hago argv1, que es un ejemplo vamos a volver a los lunes, y ejecutarlo,

1114
01:09:21,350 --> 01:09:23,370
cuenta de que no parece hacer nada.

1115
01:09:23,370 --> 01:09:25,490
Simplemente imprime su propio nombre.

1116
01:09:25,490 --> 01:09:31,479
Pero si digo adiós clase, observe que este programa aparentemente se repite

1117
01:09:31,479 --> 01:09:35,479
sobre cada una de las palabras que se escriben en el indicador.

1118
01:09:35,479 --> 01:09:41,630
Y los medios por los que vamos a tener acceso a las palabras que el usuario ha escrito en el indicador

1119
01:09:41,630 --> 01:09:49,160
es cambiando principal a partir de este fin de semana desde int main (void) para int main (argc, argv)

1120
01:09:49,160 --> 01:09:52,050
y así nacerá argumentos de línea de comandos.

1121
01:09:52,050 --> 01:09:57,100
Y una vez que estés muy sofisticado en esto, usted será capaz de escribir programas realmente trippy

1122
01:09:57,100 --> 01:09:59,610
como este aquí, que va por encima y más allá

1123
01:09:59,610 --> 01:10:03,940
algunas de las funciones que hemos hecho hasta ahora, pero todo muy potente.

1124
01:10:03,940 --> 01:10:08,950
>> Así que vamos a salir de esto con la siguiente en la pantalla, y nos vemos el lunes.

1125
01:10:17,570 --> 01:10:20,000
>> [CS50.TV]