1
00:00:00,000 --> 00:00:00,487

2
00:00:00,487 --> 00:00:11,210
>> [REPRODUCCIÓN DE MÚSICA]

3
00:00:11,210 --> 00:00:12,100
>> ROB BODEN: Muy bien.

4
00:00:12,100 --> 00:00:15,620
Así que, primero lo primero, de vídeo
a partir de una cara conocida.

5
00:00:15,620 --> 00:00:22,080

6
00:00:22,080 --> 00:00:22,560
>> [REPRODUCCIÓN DE VÍDEO]

7
00:00:22,560 --> 00:00:23,370
>> -Muy bien.

8
00:00:23,370 --> 00:00:27,150
Este es CS50, y esto es
el inicio de la tercera semana.

9
00:00:27,150 --> 00:00:29,980
Lo siento yo no podía estar allí con ustedes
hoy, pero permítame presentarle

10
00:00:29,980 --> 00:00:32,880
Propio Boden Rob CS50.

11
00:00:32,880 --> 00:00:33,872
>> [VIDEO PLAYBACK FIN]

12
00:00:33,872 --> 00:00:39,340
>> [Aplausos y vítores]

13
00:00:39,340 --> 00:00:41,277
>> ROB BODEN: La filmografía de
que el video es fantástico.

14
00:00:41,277 --> 00:00:47,280

15
00:00:47,280 --> 00:00:47,770
Está bien.

16
00:00:47,770 --> 00:00:50,960
Así que primero, hay otro almuerzo.

17
00:00:50,960 --> 00:00:52,330
Es mañana a las 1:15.

18
00:00:52,330 --> 00:00:54,480
No hay almuerzo este viernes.

19
00:00:54,480 --> 00:00:55,810
Es con Quora.

20
00:00:55,810 --> 00:01:00,190
Y Tommy aún no está aquí, pero uno de
la gente de allí es ex jefe CF,

21
00:01:00,190 --> 00:01:01,530
Tommy McWilliam.

22
00:01:01,530 --> 00:01:02,730
Así que él es un tipo divertido.

23
00:01:02,730 --> 00:01:04,819
Usted debe venir.

24
00:01:04,819 --> 00:01:05,900
>> Está bien.

25
00:01:05,900 --> 00:01:11,360
Así que la semana pasada, empezamos romperse
acerca de lo que una cadena es en realidad.

26
00:01:11,360 --> 00:01:14,830
Hemos sabido desde el principio que
que es una secuencia de caracteres.

27
00:01:14,830 --> 00:01:18,130
Pero la semana pasada, hemos profundizado en el hecho de
que lo que es en realidad una secuencia de

28
00:01:18,130 --> 00:01:22,110
personajes, bueno, ahora tenemos
arreglos de caracteres.

29
00:01:22,110 --> 00:01:26,450
Y sabemos que una cadena, que es una matriz
de personajes, al final,

30
00:01:26,450 --> 00:01:30,920
tenemos este byte nulo especial, este
barra invertida 0, que indica el final de

31
00:01:30,920 --> 00:01:32,230
la cadena.

32
00:01:32,230 --> 00:01:36,970
>> Y así, una cadena es un arreglo de
personajes, pero podemos tener más de

33
00:01:36,970 --> 00:01:39,530
sólo un conjunto de caracteres,
podemos tener una matriz de cualquier

34
00:01:39,530 --> 00:01:40,890
tipo de cosas que queremos.

35
00:01:40,890 --> 00:01:51,570
Por lo tanto, si usted recuerda de la semana pasada, el
Programa de Edad que David introdujo

36
00:01:51,570 --> 00:01:53,560
muy rápido.

37
00:01:53,560 --> 00:01:57,010
Así que lo primero que vamos a hacer es
pedir al usuario un número entero, el

38
00:01:57,010 --> 00:01:58,800
número de personas en la habitación.

39
00:01:58,800 --> 00:02:01,260
Una vez que tengamos ese entero,
estamos declarando una matriz.

40
00:02:01,260 --> 00:02:02,890
Observe esta sintaxis soporte.

41
00:02:02,890 --> 00:02:04,540
Usted va a acostumbrarse a eso.

42
00:02:04,540 --> 00:02:09,430
>> Así que estamos declarando una matriz de enteros
llaman las edades, y hay n

43
00:02:09,430 --> 00:02:12,080
enteros en esta matriz.

44
00:02:12,080 --> 00:02:16,480
Así que este patrón aquí, este 4 int
i es igual a 0, i es menor que n, i más

45
00:02:16,480 --> 00:02:20,580
además, que también va a ser un patrón
que usted consigue muy acostumbrado.

46
00:02:20,580 --> 00:02:24,000
Porque eso es más o menos cómo eres
siempre va a iterar sobre arrays.

47
00:02:24,000 --> 00:02:26,330
Así que recuerda que n es el
longitud de nuestra matriz.

48
00:02:26,330 --> 00:02:32,120
Así que aquí, estamos pidiendo repetidamente
para la edad de la persona i en la habitación.

49
00:02:32,120 --> 00:02:36,640
>> Después de esto, vamos hacia abajo, y por cualquier
razón arbitraria, entonces

50
00:02:36,640 --> 00:02:40,220
imprima la edad que van
a ser un año a partir de ahora.

51
00:02:40,220 --> 00:02:49,980
Y ejecutar ese programa, vamos a
hacer edades, punto edades slash.

52
00:02:49,980 --> 00:02:53,010
Así que el número de personas en la habitación,
digamos que hay tres.

53
00:02:53,010 --> 00:02:59,880
Y decir, la primera persona es de 13,
siguiente es 26, y el último es 30.

54
00:02:59,880 --> 00:03:05,080
Así entonces va a iterar sobre los tres
gente, imprimen 14, 27 y 31.

55
00:03:05,080 --> 00:03:16,060
>> Así que recuerde que cuando declaramos un
matriz de tamaño n, los índices en que

56
00:03:16,060 --> 00:03:19,950
matriz, la matriz tiene valores y
índices 0, 1, 2, todo el camino

57
00:03:19,950 --> 00:03:21,680
hasta n menos 1.

58
00:03:21,680 --> 00:03:26,255
Así que cuando nos dijo que había tres personas
en el cuarto, y lo ponemos aquí

59
00:03:26,255 --> 00:03:29,850
la primera iteración a través de este
bucle, i va a ser 0.

60
00:03:29,850 --> 00:03:31,650
Así que en el índice 0.

61
00:03:31,650 --> 00:03:34,540
Estamos asignando la primera
Edad El usuario introduce.

62
00:03:34,540 --> 00:03:38,870
Luego, en el siguiente, estamos entrando en el
segundo n el usuario entra, y en

63
00:03:38,870 --> 00:03:40,580
junto a dos, el último n.

64
00:03:40,580 --> 00:03:44,200
>> Así cuenta de que una matriz de tamaño
tres no tiene nada

65
00:03:44,200 --> 00:03:46,040
en el índice de tres.

66
00:03:46,040 --> 00:03:49,036
Esto no es válida.

67
00:03:49,036 --> 00:03:50,250
Está bien.

68
00:03:50,250 --> 00:03:55,136
Así que, volviendo aquí.

69
00:03:55,136 --> 00:03:57,650

70
00:03:57,650 --> 00:04:01,590
Así que ahora que hemos tratado con matrices,
tenemos cierta familiaridad.

71
00:04:01,590 --> 00:04:03,780
Ahora vamos a pasar a comandos
argumentos de la línea, que van a ser

72
00:04:03,780 --> 00:04:05,890
muy relevantes para este conjunto de problemas.

73
00:04:05,890 --> 00:04:09,670
>> Así que, hasta ahora, cada vez que usted tiene
declaró que su función principal, que hemos

74
00:04:09,670 --> 00:04:11,230
dijo void main int.

75
00:04:11,230 --> 00:04:14,070
Así vacío sólo significa que
no estamos pasando cualquier

76
00:04:14,070 --> 00:04:16,440
argumentos de esta función.

77
00:04:16,440 --> 00:04:19,190
Ahora vamos a ver que la principal
puede tomar algunos argumentos.

78
00:04:19,190 --> 00:04:22,470
Aquí los llamamos int argc
y los soportes argv cadena.

79
00:04:22,470 --> 00:04:26,930
Los soportes, una vez más, lo que indica
que estamos tratando con matrices.

80
00:04:26,930 --> 00:04:31,850
Así que aquí, entre paréntesis argv cadena, estamos
se trata de una matriz de cadenas.

81
00:04:31,850 --> 00:04:35,360
Así argc, eso va a indicar
cuántos argumentos que hemos

82
00:04:35,360 --> 00:04:37,580
pasado a este programa.

83
00:04:37,580 --> 00:04:46,050
Y para ver lo que eso significa,
vamos a cerrar esto.

84
00:04:46,050 --> 00:04:46,490
>> Aceptar.

85
00:04:46,490 --> 00:04:50,790
Así que, hasta ahora, nos hemos quedado todos
programa como las edades de la raya vertical de puntos.

86
00:04:50,790 --> 00:04:55,250
Podemos también, en la línea de comandos, más allá
pasar argumentos, de ahí el término, el comando

87
00:04:55,250 --> 00:04:56,550
argumentos de la línea.

88
00:04:56,550 --> 00:04:59,760
Así que el primer argumento, hola mundo.

89
00:04:59,760 --> 00:05:03,350
Así que aquí, argc sería tres.

90
00:05:03,350 --> 00:05:07,720
Es el recuento de los argumentos
en la línea de comandos.

91
00:05:07,720 --> 00:05:12,840
Argc es siempre al menos 1, desde el punto
recortar las edades, en sí, que cuenta como uno de

92
00:05:12,840 --> 00:05:14,490
los argumentos de la línea de comandos.

93
00:05:14,490 --> 00:05:17,010
>> Luego hola es la primera.

94
00:05:17,010 --> 00:05:20,460
Si edades slash dot es el cero, entonces
hola es la primera, y el mundo es la

95
00:05:20,460 --> 00:05:22,830
segundo argumento de la línea de comandos.

96
00:05:22,830 --> 00:05:29,490
Así que la cadena argv, vamos a ver,
contiene las cadenas, slash dot

97
00:05:29,490 --> 00:05:33,830
edades, hola, y en el mundo.

98
00:05:33,830 --> 00:05:38,945
Y, por la petición de David, vamos
para reproducir un vídeo que introducir.

99
00:05:38,945 --> 00:05:42,486

100
00:05:42,486 --> 00:05:43,890
>> [REPRODUCCIÓN DE VÍDEO]

101
00:05:43,890 --> 00:05:46,240
>> -Hasta ahora, en los programas que hemos
por escrito, hemos declaramos

102
00:05:46,240 --> 00:05:48,500
principal void main como int.

103
00:05:48,500 --> 00:05:51,170
Y todo este tiempo, ese vacío tiene
simplemente se especifica que el

104
00:05:51,170 --> 00:05:54,430
programa no toma ninguna
argumentos de la línea de comandos.

105
00:05:54,430 --> 00:05:57,750
En otras palabras, cuando un usuario ejecuta una
programa, él o ella puede proporcionar comando

106
00:05:57,750 --> 00:06:01,710
argumentos de la línea de la escritura adicional
palabras o frases después del programa

107
00:06:01,710 --> 00:06:03,000
nombre en el indicador.

108
00:06:03,000 --> 00:06:06,550
>> Bueno, si usted no desea que su programa para
tomar argumentos de línea de comandos, uno o

109
00:06:06,550 --> 00:06:10,540
más de tales palabras, tenemos que reemplazar
anular con un par de argumentos.

110
00:06:10,540 --> 00:06:12,200
Así que vamos a hacer eso.

111
00:06:12,200 --> 00:06:15,750
Incluya CS50.h.

112
00:06:15,750 --> 00:06:19,360
Incluya io.h. estándar

113
00:06:19,360 --> 00:06:20,760
Int. principal.

114
00:06:20,760 --> 00:06:26,330
Y ahora, en lugar de vacío, me voy a
especifique un entero llamado argc y una

115
00:06:26,330 --> 00:06:28,780
matriz de cadenas denominadas argv.

116
00:06:28,780 --> 00:06:31,820
Ahora, argc y argv son
simplemente convenciones.

117
00:06:31,820 --> 00:06:34,000
>> Podríamos haber llamado a estos argumentos
más lo que queramos.

118
00:06:34,000 --> 00:06:37,630
Pero lo importante es que argc es
un int porque, por definición, es

119
00:06:37,630 --> 00:06:41,360
va a contener el número del argumento, la
número de palabras en total que el

120
00:06:41,360 --> 00:06:43,380
usuario ha escrito en su solicitud.

121
00:06:43,380 --> 00:06:47,910
argv, por su parte, el argumento de vectores, es
va a ser en realidad una matriz de almacenamiento

122
00:06:47,910 --> 00:06:52,020
todas las palabras que el usuario tiene
escrito en su solicitud.

123
00:06:52,020 --> 00:06:54,500
>> Vamos a proceder a hacer algo ahora
con uno o más de estos

124
00:06:54,500 --> 00:06:55,660
argumentos de la línea de comandos.

125
00:06:55,660 --> 00:07:00,070
En particular, vamos a seguir adelante e imprimir
cualquier palabra que el usuario

126
00:07:00,070 --> 00:07:03,960
después del nombre del programa
en el indicador.

127
00:07:03,960 --> 00:07:04,730
Soporte Abrir.

128
00:07:04,730 --> 00:07:06,240
Cerrar soporte.

129
00:07:06,240 --> 00:07:10,510
Ciento Printf s barra invertida y coma.

130
00:07:10,510 --> 00:07:14,550
Y ahora tengo que decirte printf qué valor
para conectar a ese marcador de posición.

131
00:07:14,550 --> 00:07:18,600
Quiero que la primera palabra que el usuario tiene
escrito después del nombre del programa,

132
00:07:18,600 --> 00:07:23,130
y por eso me voy a especificar
argv soporte 1, cerca

133
00:07:23,130 --> 00:07:24,830
paréntesis, punto y coma.

134
00:07:24,830 --> 00:07:27,290
>> Ahora, ¿por qué el soporte 1 y que no soporte 0?

135
00:07:27,290 --> 00:07:30,990
Bueno, resulta que, almacenada automáticamente
en argv 0 va a ser el

136
00:07:30,990 --> 00:07:32,620
nombre real del programa.

137
00:07:32,620 --> 00:07:36,180
Así que la primera palabra que el usuario
después del nombre del programa es, por

138
00:07:36,180 --> 00:07:38,990
convención, va a ser
almacenado en argv 1.

139
00:07:38,990 --> 00:07:42,380
Ahora vamos a compilar y
ejecutar este programa.

140
00:07:42,380 --> 00:07:47,780
>> Hacer argv 0, slash argv punto 0.

141
00:07:47,780 --> 00:07:50,520
Y ahora una palabra como hola.

142
00:07:50,520 --> 00:07:51,670
Intro.

143
00:07:51,670 --> 00:07:53,520
Y ahí lo tenemos, hola.

144
00:07:53,520 --> 00:07:55,750
>> [VIDEO PLAYBACK FIN]

145
00:07:55,750 --> 00:07:57,000
>> ROB BODEN: Muy bien.

146
00:07:57,000 --> 00:07:59,380

147
00:07:59,380 --> 00:08:01,230
Cierra esa.

148
00:08:01,230 --> 00:08:16,730
Así que echar un vistazo a ese programa que
hemos introducido para nosotros, bueno,

149
00:08:16,730 --> 00:08:24,710
para mostrar, si imprimimos argv 0, marca, ahora
¿qué es, argv 0, slash argv punto 0.

150
00:08:24,710 --> 00:08:30,440
Así que, como se esperaba, se imprima la
el nombre del programa, ya que es argv 0

151
00:08:30,440 --> 00:08:32,970
siempre va a ser el
el nombre del programa.

152
00:08:32,970 --> 00:08:35,640
Pero vamos a hacer algo un
poco más interesante.

153
00:08:35,640 --> 00:08:42,080
>> Así, en el conjunto de problemas, usted será
introducido a esta función, atoi.

154
00:08:42,080 --> 00:08:44,440
Entonces, ¿qué es lo que utilizamos para atoi?

155
00:08:44,440 --> 00:08:48,550
Eso va a convertir una
cadena a un entero.

156
00:08:48,550 --> 00:08:53,280
Así que si paso la cadena, uno, dos, tres,
a atoi, que va a convertirlos en que

157
00:08:53,280 --> 00:08:56,910
al entero, uno, dos, tres.

158
00:08:56,910 --> 00:09:01,480
Así que vamos a convertir la primera
línea de comandos argumento en un entero,

159
00:09:01,480 --> 00:09:05,690
y luego simplemente imprimir ese entero.

160
00:09:05,690 --> 00:09:09,680
>> Así que, básicamente, estamos un poco
reimplementar getint, sólo el

161
00:09:09,680 --> 00:09:12,350
entero se introduce en el comando
línea en lugar de en el programa

162
00:09:12,350 --> 00:09:14,560
interactiva.

163
00:09:14,560 --> 00:09:23,170
Así pues, haciendo argv 0, vamos a hacer
que aquí, y cerrar esa.

164
00:09:23,170 --> 00:09:27,670
Entonces, ejecutar argv 0, y vamos a entrar en el
número entero, un dos tres cuatro uno dos.

165
00:09:27,670 --> 00:09:30,840
Así que va a imprimir el número entero, una
dos tres cuatro uno dos.

166
00:09:30,840 --> 00:09:35,500
Hay algunas sutilezas que atoi que
que va a dejar de preocuparse por nada

167
00:09:35,500 --> 00:09:39,040
más allá de un carácter numérico válido,
pero eso no importa.

168
00:09:39,040 --> 00:09:42,870
>> Entonces, ¿qué crees que sucede
si hago esto?

169
00:09:42,870 --> 00:09:45,520

170
00:09:45,520 --> 00:09:47,050
Fallo de segmentación.

171
00:09:47,050 --> 00:09:50,410
Entonces ¿por qué es eso?

172
00:09:50,410 --> 00:09:56,060
Si uno mira hacia atrás en nuestro programa, estamos
convertir argv 1, el primer argumento

173
00:09:56,060 --> 00:09:59,610
después de que el nombre del programa, a un entero.

174
00:09:59,610 --> 00:10:03,350
Pero no hay un argumento que se pasa
después de que el nombre del programa.

175
00:10:03,350 --> 00:10:08,060
Así que aquí, vemos que se trata de un buggy
programa, ya que, si tratamos de ejecutarlo

176
00:10:08,060 --> 00:10:10,530
sin ningún argumento,
simplemente se colgará.

177
00:10:10,530 --> 00:10:16,950
>> Así que otro patrón común verás
es algo así como, si argc es menos

178
00:10:16,950 --> 00:10:21,100
de dos, lo que indica que no había
por lo menos el nombre del programa y una

179
00:10:21,100 --> 00:10:29,100
primer argumento, entonces haremos algo
como printf, no es suficiente

180
00:10:29,100 --> 00:10:31,190
argumentos de la línea de comandos.

181
00:10:31,190 --> 00:10:33,170
Esto probablemente no es una buena para imprimir,
es probable que sea algo, como

182
00:10:33,170 --> 00:10:35,440
deberá ingresar un número entero
en la línea de comandos.

183
00:10:35,440 --> 00:10:37,450
Voy a terminar allí.

184
00:10:37,450 --> 00:10:39,600
Y luego volver 1.

185
00:10:39,600 --> 00:10:44,740
Así que recuerde que al final de nuestra
programa, si volvemos 0, ese tipo de

186
00:10:44,740 --> 00:10:47,060
indica el éxito.

187
00:10:47,060 --> 00:10:50,940
Y principal también automáticamente
devuelve 0 si no lo hace.

188
00:10:50,940 --> 00:10:55,800
>> Así que aquí, estamos resintonizar 1 para indicar
que ese no es el éxito.

189
00:10:55,800 --> 00:11:01,000
Y usted puede devolver lo que quieras,
simplemente, 0 indica el éxito, y

190
00:11:01,000 --> 00:11:03,390
nada indica fracaso.

191
00:11:03,390 --> 00:11:04,855
Así que vamos a ejecutar esta versión de las cosas.

192
00:11:04,855 --> 00:11:12,880

193
00:11:12,880 --> 00:11:16,600
Así que ahora, si no entramos en una línea de comandos
argumento, te dirá correctamente

194
00:11:16,600 --> 00:11:18,290
nosotros, no la línea de comandos suficiente.

195
00:11:18,290 --> 00:11:20,610
No terminó la frase.

196
00:11:20,610 --> 00:11:24,950
Si no, si realmente pasamos una,
puede completar el programa.

197
00:11:24,950 --> 00:11:27,920
Así que esto es como se puede utilizar argc en
fin de validar el número de

198
00:11:27,920 --> 00:11:30,630
Argumentos de línea de comandos que
repercusión efectiva.

199
00:11:30,630 --> 00:11:39,360
>> Así que vamos a hacer de este programa un poco más
complicado, y mirar a la segunda

200
00:11:39,360 --> 00:11:42,180
iteración de las cosas.

201
00:11:42,180 --> 00:11:46,310
Así mismo, estamos no sólo imprimir el
primer argumento de la línea de comandos.

202
00:11:46,310 --> 00:11:51,210
Aquí, estamos iterando de iguales i int
0, i es menor que argc, i más

203
00:11:51,210 --> 00:11:55,280
plus, y argv impresión, el índice i.

204
00:11:55,280 --> 00:11:59,300
Así que este patrón, de nuevo, esta es la misma
patrón como antes, excepto que en lugar

205
00:11:59,300 --> 00:12:02,600
de llamar a la variable
n, estamos usando argc.

206
00:12:02,600 --> 00:12:09,520
>> Así que esta es la iteración en cada índice
en la matriz, y la impresión de cada

207
00:12:09,520 --> 00:12:11,910
elemento de la matriz.

208
00:12:11,910 --> 00:12:20,300
Y por eso, cuando nos encontramos este programa, bueno,
No entré en cualquier línea de comandos

209
00:12:20,300 --> 00:12:22,540
argumentos, por lo que sólo imprime
el nombre del programa.

210
00:12:22,540 --> 00:12:26,053
Si entro en un montón de cosas, que va a
imprimir uno, cada uno en su propia línea.

211
00:12:26,053 --> 00:12:31,213

212
00:12:31,213 --> 00:12:32,210
>> Aceptar.

213
00:12:32,210 --> 00:12:34,770
Así que vamos a echar un paso más allá.

214
00:12:34,770 --> 00:12:38,890
Y en lugar de imprimir cada argumento
en su propia línea, vamos a imprimir cada

215
00:12:38,890 --> 00:12:42,590
carácter de cada argumento
en su propia línea.

216
00:12:42,590 --> 00:12:46,700
Así que recuerde que argv es
una matriz de cadenas.

217
00:12:46,700 --> 00:12:50,960
Entonces, ¿qué es una cadena, pero
una matriz de caracteres?

218
00:12:50,960 --> 00:12:57,140
Así que eso significa que argv es realmente una
conjunto de una matriz de caracteres.

219
00:12:57,140 --> 00:13:04,920
Así que aprovechando que,
vamos a ignorar esto por ahora.

220
00:13:04,920 --> 00:13:08,190
Vamos a considerar la cadena argv 0.

221
00:13:08,190 --> 00:13:14,170
>> Así que si queremos llevar a cada carácter de
argv 0 en su propia línea, entonces quiero

222
00:13:14,170 --> 00:13:19,500
para hacer el patrón de lo que estamos acostumbrados, i es
menos de la longitud de la matriz,

223
00:13:19,500 --> 00:13:23,990
que en este caso, es de strlen, eso es
no lo que yo quiero hacer, cadena

224
00:13:23,990 --> 00:13:26,450
s es igual a argv 0.

225
00:13:26,450 --> 00:13:30,390
Así que i es menor que la longitud de nuestro
matriz, que en este caso es una matriz

226
00:13:30,390 --> 00:13:34,410
de personajes, i plus plus.

227
00:13:34,410 --> 00:13:41,040
Y así, como vimos la semana pasada, es ideal
si nos movemos que strlen fuera

228
00:13:41,040 --> 00:13:45,210
de la condición, puesto que n será la adición de
el strlen de s cada vez que vamos

229
00:13:45,210 --> 00:13:47,720
a través del bucle, y es
No va a estar cambiando.

230
00:13:47,720 --> 00:13:50,230
Así que vamos a establecer es igual a n por aquí.

231
00:13:50,230 --> 00:13:54,260

232
00:13:54,260 --> 00:13:55,170
>> Aceptar.

233
00:13:55,170 --> 00:14:01,320
Así mismo, estamos interactuando sobre
cada índice de la matriz.

234
00:14:01,320 --> 00:14:05,630
Y por eso, si queremos imprimir cada
carácter en dicha matriz, por ciento c es

235
00:14:05,630 --> 00:14:06,880
la bandera que queremos usar
para los caracteres.

236
00:14:06,880 --> 00:14:10,750

237
00:14:10,750 --> 00:14:19,770
Y ahora una i soporte va a ser el
cadena, carácter de índice i, por lo que si el

238
00:14:19,770 --> 00:14:20,970
cuerdas eran hola.

239
00:14:20,970 --> 00:14:27,530
Entonces S 0 va a ser H, S soporte
1 habrá de correo, y así sucesivamente.

240
00:14:27,530 --> 00:14:30,800
>> Así que ahora queremos combinar
estas dos cosas.

241
00:14:30,800 --> 00:14:35,440
Queremos imprimir cada carácter
de cada argumento de la línea de comandos.

242
00:14:35,440 --> 00:14:38,950
Así que vamos a tener
un bucle For anidado.

243
00:14:38,950 --> 00:14:47,480
Y convencionalmente, el primer contador
Soy yo, el próximo va a ser j, n

244
00:14:47,480 --> 00:14:54,450
será el strlen de argv i, i
es menor que n, i plus plus.

245
00:14:54,450 --> 00:14:59,150

246
00:14:59,150 --> 00:15:06,870
Y ahora en lugar de imprimir argv i, por lo que
argv soporte i va a la lista -

247
00:15:06,870 --> 00:15:14,280
que va a ser la línea de comandos-i th
argumento argv i, j se va a

248
00:15:14,280 --> 00:15:16,925
ser el carácter j-ésimo de
el argumento-i.

249
00:15:16,925 --> 00:15:20,580

250
00:15:20,580 --> 00:15:24,810
Me desharé de esto aquí y ahora
ya que nos ponemos en ese bucle.

251
00:15:24,810 --> 00:15:33,900
Así que es equivalente a los iguales de cuerda s
argv i, y luego s soporte de j.

252
00:15:33,900 --> 00:15:36,980
>> Bueno, nosotros no tenemos que declarar
este s variable.

253
00:15:36,980 --> 00:15:44,530
En lugar de ello, sólo tendremos que combinar estos
dos en lo que teníamos, argv i, j.

254
00:15:44,530 --> 00:15:45,780
>> ALTAVOZ 1: [inaudible].

255
00:15:45,780 --> 00:15:48,850

256
00:15:48,850 --> 00:15:49,680
>> ROB BODEN: Bien dicho.

257
00:15:49,680 --> 00:15:52,936
Así que esto está roto.

258
00:15:52,936 --> 00:15:55,510
Si yo en realidad corrió, lo haríamos
han dado cuenta de esto.

259
00:15:55,510 --> 00:16:01,210
Así que el contador que me importa
en este particular para

260
00:16:01,210 --> 00:16:05,410
bucle es j, el iterador.

261
00:16:05,410 --> 00:16:08,560
Así que habría que tenga problemas,
probablemente un bucle infinito, si nos

262
00:16:08,560 --> 00:16:09,540
no había fijado que.

263
00:16:09,540 --> 00:16:12,220
Es por eso que también estamos hablando
sobre la depuración de hoy.

264
00:16:12,220 --> 00:16:13,120
>> Aceptar.

265
00:16:13,120 --> 00:16:15,240
Así que vamos a ejecutar este programa.

266
00:16:15,240 --> 00:16:21,200
Y seamos realmente agregar un printf separada
aquí que se acaba de imprimir

267
00:16:21,200 --> 00:16:27,480
otra línea, ya que esto significa cuando
ejecutar el programa, habrá un espacio en blanco

268
00:16:27,480 --> 00:16:31,830
línea entre cada carácter de
cada argumento de la línea de comandos.

269
00:16:31,830 --> 00:16:33,448
Bueno, vamos a ver lo que eso significa.

270
00:16:33,448 --> 00:16:37,310

271
00:16:37,310 --> 00:16:37,790
Oop.

272
00:16:37,790 --> 00:16:39,870
¿Tienes algún bug.

273
00:16:39,870 --> 00:16:42,860
Error implícitamente declarando
función de biblioteca strlen.

274
00:16:42,860 --> 00:16:51,630
>> Volviendo a nuestro programa, que
se olvidó de incluir el hash string.h.

275
00:16:51,630 --> 00:16:54,240

276
00:16:54,240 --> 00:16:57,730
Así string.h va a ser el
archivo de encabezado que declara

277
00:16:57,730 --> 00:16:58,980
la función strlen.

278
00:16:58,980 --> 00:17:04,650

279
00:17:04,650 --> 00:17:06,060
Bien, que compila.

280
00:17:06,060 --> 00:17:09,109
Ahora, vamos a ejecutarlo.

281
00:17:09,109 --> 00:17:10,930
Así que eso.

282
00:17:10,930 --> 00:17:17,790
Se va a imprimir nuestro
nombre del programa, hola mundo.

283
00:17:17,790 --> 00:17:23,510
Se va a imprimir cada cosa, cada
carácter, en su propia línea.

284
00:17:23,510 --> 00:17:24,540
Aceptar.

285
00:17:24,540 --> 00:17:30,625
>> Así que vamos a aprovechar esta realidad
un paso más allá.

286
00:17:30,625 --> 00:17:34,050

287
00:17:34,050 --> 00:17:39,700
Y en lugar de utilizar string.h, vamos a
pensar en cómo nos gustaría implementar nuestra propia

288
00:17:39,700 --> 00:17:41,420
función strlen.

289
00:17:41,420 --> 00:17:45,600
Así que me voy a dar de inmediato
una firma de función.

290
00:17:45,600 --> 00:17:52,900
Así que vamos a llamar en my_strlen, y es
Va a tomar una cadena como argumento,

291
00:17:52,900 --> 00:17:57,220
y esperamos volver el
longitud de esa cadena.

292
00:17:57,220 --> 00:18:03,430
Así que, ¿dónde está ese tipo?

293
00:18:03,430 --> 00:18:04,990
Sí.

294
00:18:04,990 --> 00:18:06,740
Aceptar.

295
00:18:06,740 --> 00:18:12,900
Así que recuerde de la diapositiva anterior de que
También fue de la semana pasada, que un

296
00:18:12,900 --> 00:18:18,890
arreglo de caracteres, así, una cadena,
así que digamos que esta es nuestra cadena s.

297
00:18:18,890 --> 00:18:29,870
Así que si s es la cadena, hola, a continuación,
H-E-L-L-O, en la memoria, que va a

298
00:18:29,870 --> 00:18:35,610
ser, y a continuación, esta barra invertida
0 carácter.

299
00:18:35,610 --> 00:18:39,170
>> Entonces, ¿cómo hacemos para que la longitud de s?

300
00:18:39,170 --> 00:18:43,190
Bueno, el truco está en busca de este
0 contragolpe carácter, esta nula

301
00:18:43,190 --> 00:18:44,380
terminador.

302
00:18:44,380 --> 00:18:50,270
De modo que el algoritmo se va
a ser algo así como unos pocos

303
00:18:50,270 --> 00:18:51,510
suficientes caracteres que -

304
00:18:51,510 --> 00:18:56,180
vamos a echar esta mano representan algunos
mostrador, vamos a llamar a esta longitud int.

305
00:18:56,180 --> 00:19:00,060
Así, a partir de aquí, estamos
va a iterar sobre nuestra cadena.

306
00:19:00,060 --> 00:19:04,100
>> Así que el primer carácter, es H,
y no es de nuevo slash 0, por lo que

307
00:19:04,100 --> 00:19:05,170
la longitud es 1.

308
00:19:05,170 --> 00:19:08,050
Iterar hasta el siguiente carácter,
E, y no es la barra invertida 0.

309
00:19:08,050 --> 00:19:09,630
La longitud es de 2.

310
00:19:09,630 --> 00:19:10,960
L, 3.

311
00:19:10,960 --> 00:19:11,850
L, 4.

312
00:19:11,850 --> 00:19:13,050
O, 5.

313
00:19:13,050 --> 00:19:16,690
Y, por último, llegamos a la barra invertida
0, por lo que eso significa, así,

314
00:19:16,690 --> 00:19:17,780
esta cadena ha terminado.

315
00:19:17,780 --> 00:19:20,130
Así que vamos a volver 5.

316
00:19:20,130 --> 00:19:33,630
>> Así que en realidad la aplicación que, en primer lugar,
mi longitud n es igual a 0, la mano derecha.

317
00:19:33,630 --> 00:19:36,088
Y vamos a repetir -

318
00:19:36,088 --> 00:19:38,000
>> ALTAVOZ 1: [inaudible]

319
00:19:38,000 --> 00:19:38,640
>> ROB BODEN: Oh, disparar.

320
00:19:38,640 --> 00:19:39,870
Buena decisión.

321
00:19:39,870 --> 00:19:42,680
Boom.

322
00:19:42,680 --> 00:19:44,140
Así longitud n es igual a 0.

323
00:19:44,140 --> 00:19:46,910

324
00:19:46,910 --> 00:19:58,310
Así que ahora, la duración, pero s no
igual y luego, la barra invertida 0.

325
00:19:58,310 --> 00:20:04,660
Así que recuerde, esta barra invertida 0, se trata de una
carácter real, e indica

326
00:20:04,660 --> 00:20:05,820
el final de la cadena.

327
00:20:05,820 --> 00:20:09,850
Al igual que, también, la barra invertida
n es un personaje real.

328
00:20:09,850 --> 00:20:14,040
Backslash 0 va a indicar
Al final de nuestra cadena.

329
00:20:14,040 --> 00:20:15,414
No quiero poner eso ahí.

330
00:20:15,414 --> 00:20:19,190

331
00:20:19,190 --> 00:20:25,620
Y mientras que s indexados por la longitud no es
igual al terminador nulo,

332
00:20:25,620 --> 00:20:27,130
sólo vamos a incrementar la longitud.

333
00:20:27,130 --> 00:20:29,860

334
00:20:29,860 --> 00:20:34,880
Así pues, al final de nuestro programa,
longitud finalmente se va a

335
00:20:34,880 --> 00:20:37,610
ser 5 en este caso.

336
00:20:37,610 --> 00:20:39,210
Y acabamos volveremos longitud.

337
00:20:39,210 --> 00:20:42,570

338
00:20:42,570 --> 00:20:43,530
>> Aceptar.

339
00:20:43,530 --> 00:20:48,290
Así que ahora aquí, no lo sé
hacer my_strlen.

340
00:20:48,290 --> 00:20:50,700
Vamos a compilar para asegurarse
todo funciona sin problemas.

341
00:20:50,700 --> 00:20:55,820

342
00:20:55,820 --> 00:20:58,210
Estaba haciendo en 2?

343
00:20:58,210 --> 00:21:00,565
¿O era que 1?

344
00:21:00,565 --> 00:21:01,940
Eso debería bastar.

345
00:21:01,940 --> 00:21:02,690
Está bien.

346
00:21:02,690 --> 00:21:08,490
Así que esto es argv 2.

347
00:21:08,490 --> 00:21:11,585
Funciona como se esperaba, a pesar de
era que el que yo hacía en?

348
00:21:11,585 --> 00:21:15,060

349
00:21:15,060 --> 00:21:15,550
Sí.

350
00:21:15,550 --> 00:21:16,760
Aceptar.

351
00:21:16,760 --> 00:21:21,820
Esta versión de lo que no tenía
la línea nueva después de printf, pero

352
00:21:21,820 --> 00:21:22,910
no hace ninguna diferencia.

353
00:21:22,910 --> 00:21:23,300
Aceptar.

354
00:21:23,300 --> 00:21:25,780
Así trabajó como se esperaba.

355
00:21:25,780 --> 00:21:34,750
>> Ahora incluso podemos combinar esta un paso
Además, cuando resulte aviso aquí, bueno,

356
00:21:34,750 --> 00:21:38,920
primero, estamos agarrando el strlen de argv
i, y entonces estamos interactuando sobre

357
00:21:38,920 --> 00:21:41,450
cada carácter en la cadena.

358
00:21:41,450 --> 00:21:47,480
Así que en vez de hacer eso, ¿y si nos
simplemente combinar esta lógica de la espera

359
00:21:47,480 --> 00:21:50,740
hasta que llegamos a la barra invertida 0 derecho
en este bucle?

360
00:21:50,740 --> 00:21:53,740

361
00:21:53,740 --> 00:22:07,490
Así iterar mientras argv i, j hace
es igual a 0 barra invertida.

362
00:22:07,490 --> 00:22:10,680
Así que vamos a ejecutar en primer lugar.

363
00:22:10,680 --> 00:22:19,838

364
00:22:19,838 --> 00:22:21,180
>> Está bien.

365
00:22:21,180 --> 00:22:27,655
Así que aquí, esta condición está diciendo -

366
00:22:27,655 --> 00:22:38,090

367
00:22:38,090 --> 00:22:40,060
vamos a aclarar eso.

368
00:22:40,060 --> 00:22:49,140
Así que ahora, que esto sea nuestra argv.

369
00:22:49,140 --> 00:22:55,290
Así que cuando me acaba de ejecutar ese programa antes,
argv es un array de cadenas.

370
00:22:55,290 --> 00:23:03,100
Y así, si lo ejecuto con argv slash dot
2, hola mundo, entonces el argv

371
00:23:03,100 --> 00:23:07,650
sí es la longitud 3, por argv
cero, hola, y en el mundo.

372
00:23:07,650 --> 00:23:11,700

373
00:23:11,700 --> 00:23:19,660
>> Y dentro de cada uno de estos índices, es decir,
en sí una matriz, donde esto va a ser

374
00:23:19,660 --> 00:23:23,780
punto, esto será slash, no sé
si esa era la dirección correcta, me

375
00:23:23,780 --> 00:23:25,680
no creo que era.

376
00:23:25,680 --> 00:23:30,110
A-R-V tablero, necesita más espacio.

377
00:23:30,110 --> 00:23:32,570
Vamos a cortar en el array.

378
00:23:32,570 --> 00:23:38,230
Tablero 0, y luego barra invertida 0 A-R-V.

379
00:23:38,230 --> 00:23:43,160
Y entonces en el caos será hola.

380
00:23:43,160 --> 00:23:45,910
Digamos, H-E barra invertida 0.

381
00:23:45,910 --> 00:23:51,130
Y, por último, W-O barra invertida 0.

382
00:23:51,130 --> 00:23:59,730
>> De modo que el algoritmo que sólo escribimos,
el anidado bucles, lo que están

383
00:23:59,730 --> 00:24:07,321
haciendo es, en primer lugar tenemos la
contador i y j a continuación.

384
00:24:07,321 --> 00:24:15,206
Esto sería más fácil con código en el
pantalla, Volvamos a esto.

385
00:24:15,206 --> 00:24:17,476
Aceptar.

386
00:24:17,476 --> 00:24:24,600
Entonces noto que i es el iterador que es
iterar sobre cada comando

387
00:24:24,600 --> 00:24:25,610
argumento de la línea.

388
00:24:25,610 --> 00:24:28,870
Y j es la iteración iterador
sobre cada carácter en que

389
00:24:28,870 --> 00:24:30,410
argumento de la línea de comandos.

390
00:24:30,410 --> 00:24:46,755
Así que lo que esto printf más interna está haciendo
Es decir, tenemos printf argv 0 0, printf

391
00:24:46,755 --> 00:24:58,680
argv 0 1, printf argv 0 2 0 3 0 4, 0
5, 6 0, pero ahora, argv 0 7 va a

392
00:24:58,680 --> 00:25:00,670
igualdad de barra invertida 0.

393
00:25:00,670 --> 00:25:05,730
>> Así que salimos de ese bucle,
y ahora itera a 1.

394
00:25:05,730 --> 00:25:10,910
Y ahora vamos a imprimir
argv 1 0, argv 1 1 -

395
00:25:10,910 --> 00:25:17,040
bueno, ahora, desde que me corté hola corta,
argv 1 2 El nuevo va a ser

396
00:25:17,040 --> 00:25:18,170
barra invertida 0.

397
00:25:18,170 --> 00:25:25,050
Y así, se incrementa i y continuar, y
así sucesivamente, hasta que nos imprimimos todos

398
00:25:25,050 --> 00:25:28,580
mundo, y los tres son de línea de comandos
argumentos, y vamos a salir del

399
00:25:28,580 --> 00:25:31,670
el bucle más externa, y
terminar nuestro programa.

400
00:25:31,670 --> 00:25:38,390

401
00:25:38,390 --> 00:25:39,640
Aceptar.

402
00:25:39,640 --> 00:25:43,903

403
00:25:43,903 --> 00:25:46,795
>> Así que vamos a llegar hasta aquí.

404
00:25:46,795 --> 00:25:49,670

405
00:25:49,670 --> 00:25:52,370
Así obtendrá una cierta familiaridad con
argumentos de la línea de comandos en este

406
00:25:52,370 --> 00:25:54,460
conjunto determinado problema.

407
00:25:54,460 --> 00:25:56,630
>> Ahora, la depuración.

408
00:25:56,630 --> 00:26:01,680
Así que es probable que ya haya tenido que hacer
cierta depuración con su anterior

409
00:26:01,680 --> 00:26:03,120
establece problema.

410
00:26:03,120 --> 00:26:08,420
Y una manera muy fácil de depuración,
en primer lugar, echemos un vistazo a un programa de buggy.

411
00:26:08,420 --> 00:26:20,710

412
00:26:20,710 --> 00:26:23,830
Bueno, caminar a través de este programa,
vamos a pedir al usuario para una

413
00:26:23,830 --> 00:26:29,350
entero, agarra ese entero, y luego,
arbitrariamente, tenemos un bucle while que

414
00:26:29,350 --> 00:26:32,280
sólo va a disminuir
i hasta que sea igual a 10.

415
00:26:32,280 --> 00:26:35,820
Vamos a suponer que estoy introduciendo
un número entero mayor que 10.

416
00:26:35,820 --> 00:26:38,700
Así DECREMENT i hasta que sea igual a 10.

417
00:26:38,700 --> 00:26:42,630
>> Y luego tenemos otro bucle while
que, si bien i no es igual a 0, estamos

418
00:26:42,630 --> 00:26:44,540
va a disminuir en un 3 i.

419
00:26:44,540 --> 00:26:49,790
Así que si ves la intención del error
aquí, es que esto va a decrementar i para

420
00:26:49,790 --> 00:26:57,010
ser 10, y entonces esta voluntad bucle while
i decremento del 10, a 7, a 4, a 1,

421
00:26:57,010 --> 00:27:02,880
a negativo 2, 5 a negativo, y así sucesivamente,
hasta el infinito negativo, ya que voy a

422
00:27:02,880 --> 00:27:05,920
En realidad nunca ser igual a 0.

423
00:27:05,920 --> 00:27:08,610
Y luego, al final de este programa,
tenemos la función foo que es

424
00:27:08,610 --> 00:27:12,130
pasando impresión que yo.

425
00:27:12,130 --> 00:27:16,520
>> Así que este es un programa corto y trivial,
y el error es obvio,

426
00:27:16,520 --> 00:27:18,790
sobre todo después de que acabo de
dijo cuál era el error.

427
00:27:18,790 --> 00:27:24,840
Sin embargo, la intención aquí es, bien, esto podría
realmente se ven como parte de su

428
00:27:24,840 --> 00:27:30,040
soluciones de codiciosos de la última
conjunto de problemas, y tal vez usted no tenga

429
00:27:30,040 --> 00:27:32,800
algunos bucle infinito en su programa,
y no tienes ni idea

430
00:27:32,800 --> 00:27:34,100
¿qué está causando.

431
00:27:34,100 --> 00:27:38,690
Así que una técnica de depuración muy útil
es añadir sólo printfs

432
00:27:38,690 --> 00:27:40,180
todo su código.

433
00:27:40,180 --> 00:27:49,200
>> Así que aquí quiero un printf fuera
primer bucle while.

434
00:27:49,200 --> 00:27:53,155
Y yo quiero un printf,
y yo sólo voy a imprimir i.

435
00:27:53,155 --> 00:27:55,670

436
00:27:55,670 --> 00:27:58,330
Incluso me voy a hacer primero while, i.

437
00:27:58,330 --> 00:28:05,130

438
00:28:05,130 --> 00:28:09,040
En el exterior, mientras que el segundo bucle.

439
00:28:09,040 --> 00:28:12,170
Una vez más, imprima el interior
de aquí, el valor de i.

440
00:28:12,170 --> 00:28:16,270

441
00:28:16,270 --> 00:28:17,520
Y vamos a correr esto.

442
00:28:17,520 --> 00:28:22,620

443
00:28:22,620 --> 00:28:24,800
>> Debug slash Así punto.

444
00:28:24,800 --> 00:28:25,610
Introduzca un número entero.

445
00:28:25,610 --> 00:28:28,150
Vamos a hacer 13.

446
00:28:28,150 --> 00:28:28,760
Y de golpe.

447
00:28:28,760 --> 00:28:33,300
Vemos que estamos bucle infinito
dentro del segundo bucle while.

448
00:28:33,300 --> 00:28:36,305
Así que ahora que sabemos lo que el error es.

449
00:28:36,305 --> 00:28:39,610

450
00:28:39,610 --> 00:28:45,610
Pero la depuración printf es perfectamente bien,
pero una vez que sus programas obtienen

451
00:28:45,610 --> 00:28:50,560
más largo y complicado, hay
soluciones más sofisticadas a

452
00:28:50,560 --> 00:28:51,705
hacer las cosas de trabajo.

453
00:28:51,705 --> 00:28:52,955
Así que vamos a eliminar todos estos printfs.

454
00:28:52,955 --> 00:29:06,242

455
00:29:06,242 --> 00:29:08,896
Y vamos a asegurarnos de que no lo hice
romper nada.

456
00:29:08,896 --> 00:29:09,850
Aceptar.

457
00:29:09,850 --> 00:29:14,180
>> Así que el programa que vamos
introducir se llama

458
00:29:14,180 --> 00:29:16,715
GDB, para GNU depurador.

459
00:29:16,715 --> 00:29:21,892

460
00:29:21,892 --> 00:29:27,510
Bueno, en realidad, vamos a eliminar de depuración para
una segunda, y hacer de depuración de nuevo.

461
00:29:27,510 --> 00:29:31,420

462
00:29:31,420 --> 00:29:34,440
Bueno, en realidad en primer lugar, una buena lección
en los argumentos de línea de comandos.

463
00:29:34,440 --> 00:29:37,780
Tenga en cuenta que este comando Clang es
compilar todo se está pasando

464
00:29:37,780 --> 00:29:41,300
en la línea de comandos, estos valores
argumentos de la línea de comandos.

465
00:29:41,300 --> 00:29:46,250
Entonces, ¿cómo se va a utilizar
argumentos de la línea de comandos, como se

466
00:29:46,250 --> 00:29:51,500
lo hizo antes, y lo que quieras en PSET
2, así es como Clang los está usando.

467
00:29:51,500 --> 00:30:00,070
>> Así que darse cuenta de que esta primera bandera, guión
ggdb3, lo que está diciendo es: Clang,

468
00:30:00,070 --> 00:30:03,790
usted debe compilar este archivo con el
intención de que con el tiempo se

469
00:30:03,790 --> 00:30:05,380
necesario para depurarlo.

470
00:30:05,380 --> 00:30:13,840
Así que, mientras usted tiene esa bandera,
entonces podemos GDB depuración.

471
00:30:13,840 --> 00:30:17,380
Y va a abrir el depurador de GNU.

472
00:30:17,380 --> 00:30:22,920
>> Así que hay una gran cantidad de comandos
que tiene que acostumbrarse.

473
00:30:22,920 --> 00:30:27,100
El primero que probablemente
inmediatamente necesitar está en Ejecutar.

474
00:30:27,100 --> 00:30:28,200
Entonces, ¿qué es Ejecutar va a hacer?

475
00:30:28,200 --> 00:30:30,910
Esto va a empezar nuestro programa.

476
00:30:30,910 --> 00:30:36,180
Corred de tal manera, al iniciar el programa, el programa
nos pide un número entero de 13.

477
00:30:36,180 --> 00:30:39,170
Y entonces es un bucle infinito como
era de esperar, excepto Quité el

478
00:30:39,170 --> 00:30:40,500
printfs, por lo que ni siquiera vemos eso.

479
00:30:40,500 --> 00:30:43,320

480
00:30:43,320 --> 00:30:44,600
Salió con normalidad.

481
00:30:44,600 --> 00:30:45,850
Oh.

482
00:30:45,850 --> 00:30:48,570

483
00:30:48,570 --> 00:30:53,640
Es posible que envuelve todo el
revés, de nuevo a - ignorar eso.

484
00:30:53,640 --> 00:30:55,170
Supongamos que no salir normalmente.

485
00:30:55,170 --> 00:30:59,500

486
00:30:59,500 --> 00:31:03,370
Hay una respuesta complicada que eso.

487
00:31:03,370 --> 00:31:07,890
>> Así que ahora, eso no es muy útil.

488
00:31:07,890 --> 00:31:11,480
Por lo que sólo se ejecuta nuestro programa en el interior de
Este depurador no nos ayuda en cualquier

489
00:31:11,480 --> 00:31:15,610
manera, ya que podríamos haber hecho
dot slash depuración desde fuera del BGF.

490
00:31:15,610 --> 00:31:21,250
Así el comando que
probablemente te -

491
00:31:21,250 --> 00:31:22,970
y voy a salir de esta.

492
00:31:22,970 --> 00:31:25,850
-Control d o dejar de fumar, tanto en el trabajo.

493
00:31:25,850 --> 00:31:29,550
Así que vamos a abrir de nuevo.

494
00:31:29,550 --> 00:31:31,130
>> Otro comando que probablemente
inmediatamente querer

495
00:31:31,130 --> 00:31:33,600
acostumbrarse es Break.

496
00:31:33,600 --> 00:31:37,120
Así que vamos a romper el principal, por ahora,
y luego voy a explicar eso.

497
00:31:37,120 --> 00:31:41,010

498
00:31:41,010 --> 00:31:46,370
Bueno, aquí vemos establecemos un punto de interrupción
en esta línea en debug.c.

499
00:31:46,370 --> 00:31:50,160
Entonces, ¿qué significa ruptura es que cuando
escribir ejecutar, el programa va a

500
00:31:50,160 --> 00:31:53,560
continuará funcionando hasta que
Me golpeó un punto de interrupción.

501
00:31:53,560 --> 00:31:59,390
Así que cuando llegué a la ejecución, el programa se inicia,
y a continuación, se rompe tan pronto como se

502
00:31:59,390 --> 00:32:01,940
entra en la función principal.

503
00:32:01,940 --> 00:32:06,930
Romper principal va a ser algo
usted bastante común hace.

504
00:32:06,930 --> 00:32:11,340
>> Y ahora, para presentarle
a algunos más comandos.

505
00:32:11,340 --> 00:32:14,330
Nótese aquí, que está diciendo que
se rompió en la línea 11, que es

506
00:32:14,330 --> 00:32:16,230
printf, introduzca un entero.

507
00:32:16,230 --> 00:32:21,260
Entonces el comando siguiente va a ser la forma en
nos vamos a la siguiente línea de código.

508
00:32:21,260 --> 00:32:24,810
Esto va a permitir que demos un paso
a través de nuestra línea de programa por línea.

509
00:32:24,810 --> 00:32:26,260
Así que la próxima.

510
00:32:26,260 --> 00:32:29,820
>> Ahora la línea 12, que vamos
para obtener el número entero.

511
00:32:29,820 --> 00:32:30,450
Siguiente.

512
00:32:30,450 --> 00:32:34,290
Y si simplemente pulse la tecla Enter de nuevo, que va a
rehacer la última cosa que hizo.

513
00:32:34,290 --> 00:32:36,480
Así que no tengo que escribir
al lado cada vez.

514
00:32:36,480 --> 00:32:40,100
Así que entrar en un entero de 13.

515
00:32:40,100 --> 00:32:46,940
Así que ahora, la línea 14, mientras que i es mayor
de 10, y voy a hacer a continuación.

516
00:32:46,940 --> 00:32:48,685
Y vemos que vamos a disminuir i.

517
00:32:48,685 --> 00:32:50,210
Así que vamos a disminuir i de nuevo.

518
00:32:50,210 --> 00:32:53,620
>> Así que ahora, otra utilidad
comando es Imprimir.

519
00:32:53,620 --> 00:32:55,750
Así impresión se va a imprimir
el valor de la variable.

520
00:32:55,750 --> 00:32:57,825
Vamos a poner de manifiesto el valor
de i variable.

521
00:32:57,825 --> 00:32:58,705
Vamos a imprimir i.

522
00:32:58,705 --> 00:33:00,910
Se va a decir i es 11.

523
00:33:00,910 --> 00:33:03,330
Ahora estamos de nuevo en Siguiente, mientras
i es mayor que 10.

524
00:33:03,330 --> 00:33:05,590
Así que es aún mayor que
10, ya que es 11.

525
00:33:05,590 --> 00:33:06,920
i minus minus.

526
00:33:06,920 --> 00:33:08,250
Vamos a imprimir i de nuevo.

527
00:33:08,250 --> 00:33:10,950
Como era de esperar, es 10.

528
00:33:10,950 --> 00:33:12,510
>> Así que ahora, al lado.

529
00:33:12,510 --> 00:33:16,250
Se va de nuevo a la condición, i es
mayor de 10, pero i es ahora 10, por lo que

530
00:33:16,250 --> 00:33:20,040
no es mayor que 10, por lo que esperamos
que se caiga del bucle while.

531
00:33:20,040 --> 00:33:22,220
Y ahora estamos por debajo de la línea de código.

532
00:33:22,220 --> 00:33:28,750
Y otro comando, Lista, sólo va
para mostrar la anterior y siguiente

533
00:33:28,750 --> 00:33:31,240
par de líneas de código, en
caso de que perdió a sí mismo.

534
00:33:31,240 --> 00:33:35,420
Así que sólo salía de este bucle while,
y ahora hemos entrado en esta

535
00:33:35,420 --> 00:33:37,080
while, línea 18.

536
00:33:37,080 --> 00:33:39,860
Así, mientras que i no es igual a 0.

537
00:33:39,860 --> 00:33:46,570
Y, a continuación, i es igual a i menos 3, y vamos a
notar, esto sólo va a seguir adelante.

538
00:33:46,570 --> 00:33:48,270
Y podemos imprimir i.

539
00:33:48,270 --> 00:33:49,990
>> Cada comando tiene una especie de atajos.

540
00:33:49,990 --> 00:33:51,720
Entonces p es la abreviatura de impresión.

541
00:33:51,720 --> 00:33:53,400
Así que puede p i.

542
00:33:53,400 --> 00:33:57,550
Hemos de tener la celebración de n,
o seguir haciendo en Siguiente.

543
00:33:57,550 --> 00:33:58,340
Imprimir i de nuevo.

544
00:33:58,340 --> 00:34:00,380
Usted ve ahora es negativo 167.

545
00:34:00,380 --> 00:34:06,030
Así que esto va a durar para siempre, pero no
realmente para siempre, ya que acaba de ver, es

546
00:34:06,030 --> 00:34:09,330
terminará en realidad en algún momento.

547
00:34:09,330 --> 00:34:15,699
>> Así que empieza GDB.

548
00:34:15,699 --> 00:34:19,504
Pero vamos a hacer una cosa más en GDB.

549
00:34:19,504 --> 00:34:20,754
Uh, de depuración.

550
00:34:20,754 --> 00:34:23,540

551
00:34:23,540 --> 00:34:28,534
Así, en este caso particular, la
bucle infinito pasó a estar dentro de

552
00:34:28,534 --> 00:34:30,050
la función principal.

553
00:34:30,050 --> 00:34:35,779
Y por ahora, sólo aceptar que que soy
va a mover el bucle infinito en

554
00:34:35,779 --> 00:34:37,029
la función foo.

555
00:34:37,029 --> 00:34:40,679

556
00:34:40,679 --> 00:34:43,730
Sólo recuerde que, al final de este
programa, bueno, esto fue originalmente

557
00:34:43,730 --> 00:34:46,210
llamar a foo, que era
va a imprimir i.

558
00:34:46,210 --> 00:34:51,880
Pero ahora estamos llamando foo, que es
va a disminuir i hasta que sea 0, y

559
00:34:51,880 --> 00:34:54,548
a continuación, imprimir esa variable.

560
00:34:54,548 --> 00:34:55,469
Aceptar.

561
00:34:55,469 --> 00:34:57,970
Guarde eso.

562
00:34:57,970 --> 00:35:00,175
Hacer debug.

563
00:35:00,175 --> 00:35:03,310
Y ahora, de depuración gdb.

564
00:35:03,310 --> 00:35:04,090
Aceptar.

565
00:35:04,090 --> 00:35:10,580
>> Así que si sólo Corro entonces yo no voy a
poder dar un paso en realidad a través de mi

566
00:35:10,580 --> 00:35:11,730
línea por línea de programa.

567
00:35:11,730 --> 00:35:19,820
Así que vamos a romper en el principal,
y escriba plazo.

568
00:35:19,820 --> 00:35:28,160
Así que pasar por esto, printf, introduzca
un entero, obtener el número entero de 13.

569
00:35:28,160 --> 00:35:34,180

570
00:35:34,180 --> 00:35:37,490
Así que vamos a seguir decremento
hasta que i es mayor que 10.

571
00:35:37,490 --> 00:35:42,840
Entonces vamos a caer a través de la
while, y llegar a la línea -

572
00:35:42,840 --> 00:35:44,364
vamos a abrir para arriba en una ventana separada.

573
00:35:44,364 --> 00:35:48,720

574
00:35:48,720 --> 00:35:53,300
Así que disminuye hasta que yo ya no era
mayor que 10, y luego

575
00:35:53,300 --> 00:35:55,700
llamada a la función, foo.

576
00:35:55,700 --> 00:36:01,340
>> ¿Y qué pasó tan pronto como me golpeó
function foo, bueno, me llama foo, y

577
00:36:01,340 --> 00:36:04,030
entonces ya no tuve control sobre GDB.

578
00:36:04,030 --> 00:36:10,230
Así que tan pronto como me golpeó en Siguiente en esta línea,
cosas continuaron hasta que pasó esto,

579
00:36:10,230 --> 00:36:12,400
donde el programa salió al -

580
00:36:12,400 --> 00:36:14,450
asuma que no existía el tiempo.

581
00:36:14,450 --> 00:36:16,390
Usted lo vio hacer una pausa por un momento sin embargo.

582
00:36:16,390 --> 00:36:22,040
Entonces, ¿por qué he perdido el control sobre
el programa en ese momento?

583
00:36:22,040 --> 00:36:27,540
Bueno, cuando escribo a continuación, que se destina a
la siguiente línea de código literal que

584
00:36:27,540 --> 00:36:28,850
se ejecutará.

585
00:36:28,850 --> 00:36:35,950
Así que después de la línea 21, la siguiente línea de código
que se ejecutará es la línea 22,

586
00:36:35,950 --> 00:36:38,520
que es, que sale de principal.

587
00:36:38,520 --> 00:36:43,810
Así que no me quiero ir
a la siguiente línea de código.

588
00:36:43,810 --> 00:36:48,170
Yo quiero entrar en la función, foo,
y luego también paso a paso

589
00:36:48,170 --> 00:36:49,830
esas líneas de código.

590
00:36:49,830 --> 00:36:53,726
>> Así que por eso, tenemos una alternativa.

591
00:36:53,726 --> 00:36:56,770
Dejemos de eso otra vez.

592
00:36:56,770 --> 00:36:58,020
Romper principal.

593
00:36:58,020 --> 00:37:00,520

594
00:37:00,520 --> 00:37:06,370
Uh, 1, siguiente, siguiente, el 13, al lado,
siguiente, siguiente, con cuidado,

595
00:37:06,370 --> 00:37:09,820
antes de echarnos a foo línea.

596
00:37:09,820 --> 00:37:10,520
Aceptar.

597
00:37:10,520 --> 00:37:13,700
>> Así que ahora, que estamos en la línea 21,
donde llamamos foo.

598
00:37:13,700 --> 00:37:17,100
No queremos que escriba al lado, ya que
se acaba de llamar a la función foo, y

599
00:37:17,100 --> 00:37:18,710
ir a la siguiente línea de código.

600
00:37:18,710 --> 00:37:20,840
Lo que queremos utilizar es el Paso.

601
00:37:20,840 --> 00:37:25,690
Así que hay una diferencia entre el Paso
y Next, donde el paso entra a la

602
00:37:25,690 --> 00:37:28,190
funcionar, y Next va
sobre la función.

603
00:37:28,190 --> 00:37:32,830
Simplemente ejecuta la totalidad de
la función y sigue subiendo.

604
00:37:32,830 --> 00:37:37,210
>> Así que paso nos va a traer
en la función, foo.

605
00:37:37,210 --> 00:37:41,160
Y vemos aquí, ahora, estamos de vuelta en
este bucle while que es, en teoría,

606
00:37:41,160 --> 00:37:44,190
va a continuar para siempre.

607
00:37:44,190 --> 00:37:50,420
Y si se golpea Paso, cuando ni siquiera es
una función para llamar, entonces es

608
00:37:50,420 --> 00:37:51,720
idéntica al siguiente.

609
00:37:51,720 --> 00:37:55,320
Así que es sólo cuando usted está en una línea que
está llamando a una función que Step

610
00:37:55,320 --> 00:37:56,970
va a diferir de Siguiente.

611
00:37:56,970 --> 00:37:57,930
Así Paso nos traerá aquí.

612
00:37:57,930 --> 00:38:02,100
Paso, paso, paso, paso, paso, paso, y
Tendremos bucle infinito para siempre.

613
00:38:02,100 --> 00:38:06,810
>> Así que es posible acostumbrarse a que, como su
forma de identificar bucles infinitos, es

614
00:38:06,810 --> 00:38:08,960
sólo la celebración de esta tecla Enter para
ver dónde te quedas atascado.

615
00:38:08,960 --> 00:38:11,610

616
00:38:11,610 --> 00:38:14,780
Hay mejores maneras de hacerlo, pero
por ahora, esto es perfectamente suficiente.

617
00:38:14,780 --> 00:38:17,967
Y estilísticamente, para cumplir con Estilo
50, que debería haber hecho esto.

618
00:38:17,967 --> 00:38:21,550

619
00:38:21,550 --> 00:38:24,030
Aceptar.

620
00:38:24,030 --> 00:38:28,400
>> Así que una última orden a introducir.

621
00:38:28,400 --> 00:38:30,810
Bueno, vamos a gdb depuración pulg

622
00:38:30,810 --> 00:38:35,580
Así que en lugar de romper en principal, si
conocer la función foo es también el

623
00:38:35,580 --> 00:38:39,230
problema, entonces yo podría tener sólo
dijo, romper en foo, en su lugar.

624
00:38:39,230 --> 00:38:42,310
Digamos que yo rompo en
tanto principal y foo.

625
00:38:42,310 --> 00:38:45,390
Así que usted puede configurar tantos puntos de interrupción
como quieras.

626
00:38:45,390 --> 00:38:49,230
Cuando escribo plazo, que va
para parar en el -

627
00:38:49,230 --> 00:38:52,180
ooh, vamos a volver a compilar, ya que
He cambiado las cosas.

628
00:38:52,180 --> 00:38:55,950
Usted verá esta línea, Advertencia, fuente
archivo es más reciente que la ejecutable.

629
00:38:55,950 --> 00:38:59,680
Así que eso significa que me fui de aquí
y cambiado estos para ajustarse a Estilo

630
00:38:59,680 --> 00:39:03,100
50, pero no a compilar
el programa.

631
00:39:03,100 --> 00:39:04,870
Así GDB me hace consciente de eso.

632
00:39:04,870 --> 00:39:10,130
Dejaré, hacer debug de nuevo,
golpear debug gdb.

633
00:39:10,130 --> 00:39:10,700
Aceptar.

634
00:39:10,700 --> 00:39:12,800
>> Así que ahora, de vuelta a lo que estaba haciendo.

635
00:39:12,800 --> 00:39:15,720
Romper principal foo, romper.

636
00:39:15,720 --> 00:39:20,680
Ahora bien, si ejecuto el programa, por lo que es
va a continuar hasta que realiza un

637
00:39:20,680 --> 00:39:21,320
punto de interrupción.

638
00:39:21,320 --> 00:39:24,680
Ese punto de interrupción pasa a
ser el primero en principal.

639
00:39:24,680 --> 00:39:28,630
Ahora, en vez de hacer las siguiente, siguiente, siguiente,
siguiente, siguiente, hasta que llegué a foo, I

640
00:39:28,630 --> 00:39:35,230
puede escribir continuar, que continuará
hasta llegar a la siguiente punto de interrupción.

641
00:39:35,230 --> 00:39:37,200
Tengo que introducir el número entero primero.

642
00:39:37,200 --> 00:39:40,570
Continuar continuará hasta que llegué a la
siguiente punto de interrupción, que es que

643
00:39:40,570 --> 00:39:43,320
función de foo.

644
00:39:43,320 --> 00:39:50,130
>> Así Run se ejecutará hasta llegar a un
punto de ruptura, pero sólo se escribe de ejecución cuando

645
00:39:50,130 --> 00:39:54,060
vas a empezar el programa y, a continuación,
a partir de entonces, es continuar.

646
00:39:54,060 --> 00:40:01,950
Si acabo de hacer romper principal y
luego corrió, se va a romper en

647
00:40:01,950 --> 00:40:03,670
principal, y luego continuar.

648
00:40:03,670 --> 00:40:10,050
Como yo no tengo un punto de quiebre en foo,
introducir el número entero, entonces ahora estoy

649
00:40:10,050 --> 00:40:11,380
no va a romper a foo.

650
00:40:11,380 --> 00:40:16,318
Sólo va a infinito
bucle hasta que.

651
00:40:16,318 --> 00:40:17,568
Aceptar.

652
00:40:17,568 --> 00:40:19,500

653
00:40:19,500 --> 00:40:24,420
>> Así que eso es Introducción a GDB.

654
00:40:24,420 --> 00:40:27,790
Usted debe comenzar a usarlo
en sus boletines de problemas.

655
00:40:27,790 --> 00:40:30,550
Puede ser muy útil
para identificar errores.

656
00:40:30,550 --> 00:40:35,280
Si realmente justo, línea por línea, vaya
a través de su código, y comparar lo que es

657
00:40:35,280 --> 00:40:39,740
sucediendo realmente con lo que se espera
a suceder, entonces es bastante

658
00:40:39,740 --> 00:40:41,060
difícil pasar por alto sus errores.

659
00:40:41,060 --> 00:40:45,280

660
00:40:45,280 --> 00:40:46,530
Aceptar.

661
00:40:46,530 --> 00:40:48,310

662
00:40:48,310 --> 00:40:54,040
>> Así que la semana pasada David hizo subir este
cosas secretas Criptografía de clave para la

663
00:40:54,040 --> 00:40:59,350
primera vez, donde no queremos
contraseñas sólo pueden almacenar en nuestro

664
00:40:59,350 --> 00:41:03,210
computadora en algún archivo de texto sin formato, donde
alguien puede venir y simplemente

665
00:41:03,210 --> 00:41:04,660
abrirlo y leerlo.

666
00:41:04,660 --> 00:41:07,530
Lo ideal es que se cifran
de algún modo.

667
00:41:07,530 --> 00:41:13,340
Y en ejercicios 2, se le trata
con un método de cifrado,

668
00:41:13,340 --> 00:41:16,520
O, bueno, dos métodos, pero
que no son tan grandes.

669
00:41:16,520 --> 00:41:20,050
Si lo hace la edición hacker, eres
también va a estar tratando con

670
00:41:20,050 --> 00:41:22,150
descifrar algunas cosas.

671
00:41:22,150 --> 00:41:29,770
>> Así que la cuestión ahora es, bueno, incluso si
tenemos el cifrado más potente

672
00:41:29,770 --> 00:41:34,830
algoritmo en el mundo, si usted elige un
particularmente pobre contraseña, entonces

673
00:41:34,830 --> 00:41:37,720
no le ayudará mucho, ya que las personas
todavía será capaz de entenderlo.

674
00:41:37,720 --> 00:41:41,530
Aunque viendo la cadena cifrada y
parece un lío de basura

675
00:41:41,530 --> 00:41:44,760
que no significa nada para ellos, si
aún sólo tiene que probar un par de contraseñas

676
00:41:44,760 --> 00:41:50,560
para entenderlo, entonces usted
no son muy seguras.

677
00:41:50,560 --> 00:41:55,890
Así que ver un video que
hace que ese punto.

678
00:41:55,890 --> 00:41:59,587

679
00:41:59,587 --> 00:42:00,970
>> [REPRODUCCIÓN DE VÍDEO]

680
00:42:00,970 --> 00:42:02,100
>> -Casco, usted Demonio.

681
00:42:02,100 --> 00:42:03,370
¿Qué está pasando?

682
00:42:03,370 --> 00:42:05,170
¿Qué estás haciendo con mi hija?

683
00:42:05,170 --> 00:42:09,910
>> Me-Permitidme que introducir el brillante
joven cirujano plástico, el Dr. Phillip

684
00:42:09,910 --> 00:42:13,730
Schlotkin, el más grande de la nariz
hombre de trabajo en todo el

685
00:42:13,730 --> 00:42:16,080
universo, y Beverly Hills.

686
00:42:16,080 --> 00:42:17,210
>> -Su Alteza.

687
00:42:17,210 --> 00:42:18,070
>> -Nariz trabajo?

688
00:42:18,070 --> 00:42:18,670
No entiendo.

689
00:42:18,670 --> 00:42:20,090
Ella ya ha tenido una cirugía de nariz.

690
00:42:20,090 --> 00:42:21,910
Fue un dulce dieciséis presente.

691
00:42:21,910 --> 00:42:22,140
>> -No.

692
00:42:22,140 --> 00:42:23,690
No es lo que piensas.

693
00:42:23,690 --> 00:42:25,420
Es mucho, mucho peor.

694
00:42:25,420 --> 00:42:30,300
Si no me das la combinación de
el escudo de aire, el Dr. Schlotkin se

695
00:42:30,300 --> 00:42:34,226
dar a su hija de vuelta a su antigua nariz.

696
00:42:34,226 --> 00:42:35,476
>> -No.

697
00:42:35,476 --> 00:42:38,712

698
00:42:38,712 --> 00:42:40,516
¿De dónde sacaste eso?

699
00:42:40,516 --> 00:42:41,440
>> -Muy bien.

700
00:42:41,440 --> 00:42:42,180
Te lo diré.

701
00:42:42,180 --> 00:42:43,381
Te lo diré.

702
00:42:43,381 --> 00:42:44,263
No, papá.

703
00:42:44,263 --> 00:42:45,590
No, no debes hacerlo.

704
00:42:45,590 --> 00:42:46,860
>> -Tienes razón, querida.

705
00:42:46,860 --> 00:42:48,450
Voy a extrañar su nueva nariz.

706
00:42:48,450 --> 00:42:52,090
Pero yo no le voy a decir la combinación,
no importa qué.

707
00:42:52,090 --> 00:42:53,680
>> -Muy bien.

708
00:42:53,680 --> 00:42:55,685
Dr. Schlotkin, haz lo que quieras.

709
00:42:55,685 --> 00:42:56,914
>> -Es un placer.

710
00:42:56,914 --> 00:43:00,690
>> [TOOLS se agudizó]

711
00:43:00,690 --> 00:43:01,910
>> -No.

712
00:43:01,910 --> 00:43:02,520
Espere.

713
00:43:02,520 --> 00:43:03,836
Espere.

714
00:43:03,836 --> 00:43:05,300
Te lo diré.

715
00:43:05,300 --> 00:43:06,880
Te lo diré.

716
00:43:06,880 --> 00:43:09,130
>> -Yo sabía que iba a funcionar.

717
00:43:09,130 --> 00:43:09,900
Está bien.

718
00:43:09,900 --> 00:43:12,850
Dámelo.

719
00:43:12,850 --> 00:43:16,918
>> -La combinación es uno.

720
00:43:16,918 --> 00:43:17,406
>> -Uno.

721
00:43:17,406 --> 00:43:18,382
>> -Uno.

722
00:43:18,382 --> 00:43:19,358
>> -Dos.

723
00:43:19,358 --> 00:43:19,846
>> -Dos.

724
00:43:19,846 --> 00:43:20,822
>> -Dos.

725
00:43:20,822 --> 00:43:21,310
>> -Tres.

726
00:43:21,310 --> 00:43:21,798
>> -Tres.

727
00:43:21,798 --> 00:43:22,774
>> -Tres.

728
00:43:22,774 --> 00:43:23,262
>> -Cuatro.

729
00:43:23,262 --> 00:43:23,750
>> -Cuatro.

730
00:43:23,750 --> 00:43:26,150
>> -Cuatro.

731
00:43:26,150 --> 00:43:27,010
>> -Cinco.

732
00:43:27,010 --> 00:43:27,670
>> -Cinco.

733
00:43:27,670 --> 00:43:29,010
>> -Cinco.

734
00:43:29,010 --> 00:43:34,770
>> -Así que la combinación es uno,
dos, tres, cuatro, cinco.

735
00:43:34,770 --> 00:43:37,460
Esa es la combinación más estúpida
Que he oído en mi vida.

736
00:43:37,460 --> 00:43:39,710
Ese es el tipo de cosa que un idiota
tendría en su equipaje.

737
00:43:39,710 --> 00:43:42,000
>> -Gracias, Alteza.

738
00:43:42,000 --> 00:43:43,530
>> -¿Qué hiciste?

739
00:43:43,530 --> 00:43:44,490
>> -Apagué la pared.

740
00:43:44,490 --> 00:43:45,420
>> -No, no lo hiciste.

741
00:43:45,420 --> 00:43:45,840
Apagó la película entera.

742
00:43:45,840 --> 00:43:46,930
>> -Debo de haber pulsado el botón equivocado.

743
00:43:46,930 --> 00:43:48,265
>> -Bueno, lo puso de nuevo.

744
00:43:48,265 --> 00:43:49,110
Coloque la película de nuevo.

745
00:43:49,110 --> 00:43:49,510
>> -Sí, señor.

746
00:43:49,510 --> 00:43:49,917
Sí, señor.

747
00:43:49,917 --> 00:43:50,324
>> -Vamos, Arnold.

748
00:43:50,324 --> 00:43:51,140
Venga, Gretchen.

749
00:43:51,140 --> 00:43:53,060
Por supuesto, usted sabe que yo seguiré
tener que cobrarle por esto.

750
00:43:53,060 --> 00:43:53,440
>> [VIDEO PLAYBACK FIN]

751
00:43:53,440 --> 00:43:54,690
>> ROB BODEN: Muy bien.

752
00:43:54,690 --> 00:43:59,690

753
00:43:59,690 --> 00:44:08,430
Así que ahora que ya estamos hablando de
seguridad en algunas maneras, agradable

754
00:44:08,430 --> 00:44:16,050
pequeño cartel de la película, por lo que en los últimos años
día, estos temas con la NSA

755
00:44:16,050 --> 00:44:17,300
el seguimiento de todo.

756
00:44:17,300 --> 00:44:21,840

757
00:44:21,840 --> 00:44:26,930
Puede ser difícil para sentir que
tener algún tipo de intimidad en el

758
00:44:26,930 --> 00:44:34,540
mundo en línea, aunque no podría decir
que la mayor parte de los detalles de PRISM.

759
00:44:34,540 --> 00:44:42,130
Así que ir más allá de PRISM, no vamos
a hablar de eso, ahora

760
00:44:42,130 --> 00:44:44,030
pensar en su computadora portátil.

761
00:44:44,030 --> 00:44:48,360
Así que aquí, quiero cambiar
en mi cuenta real,

762
00:44:48,360 --> 00:44:50,370
con mi pequeño pingüino.

763
00:44:50,370 --> 00:44:57,310
Así que tengo una contraseña establecida, y que
contraseña es lo que yo quiero que sea.

764
00:44:57,310 --> 00:45:02,430
>> Pero recuerde que lo que estoy tala
con, por lo que este inicio de sesión

765
00:45:02,430 --> 00:45:04,850
pronta, es un programa.

766
00:45:04,850 --> 00:45:07,910
Es un programa que fue
escrito por alguna persona.

767
00:45:07,910 --> 00:45:13,250
Y así, esta persona, si son
particularmente malicioso, que pudieron

768
00:45:13,250 --> 00:45:17,780
han dicho, está bien, así que si la contraseña
que entro es igual a mi

769
00:45:17,780 --> 00:45:22,800
contraseña real, o es igual
en cierta contraseña especial -

770
00:45:22,800 --> 00:45:25,550
David es increíble o algo -

771
00:45:25,550 --> 00:45:27,190
luego dejarlos entrar

772
00:45:27,190 --> 00:45:33,760
Así que un programador malicioso podría tener
el acceso a todas sus Macs, o

773
00:45:33,760 --> 00:45:36,150
De Windows, o cualquier cosa.

774
00:45:36,150 --> 00:45:41,980
>> Así que no es una gran preocupación, ya que,
Quiero decir, este es el programa de inicio de sesión

775
00:45:41,980 --> 00:45:48,720
eso se envía con OS X, cientos
o miles de personas tienen

776
00:45:48,720 --> 00:45:50,020
revisado este código.

777
00:45:50,020 --> 00:45:55,330
Y así, si, en el código en alguna parte, usted
decir si esta cadena es igual a los iguales

778
00:45:55,330 --> 00:45:58,860
David es impresionante, inicio de sesión, entonces alguien está
va a ser, como, espere.

779
00:45:58,860 --> 00:45:59,800
Esto no está bien.

780
00:45:59,800 --> 00:46:01,790
Esto no debería estar aquí.

781
00:46:01,790 --> 00:46:06,650
Así que esa es una manera de hacer las cosas
a ser una especie de seguro.

782
00:46:06,650 --> 00:46:10,300
>> Pero piensa en programas incluso
que usted escribe.

783
00:46:10,300 --> 00:46:13,000
Digamos que usted escribió el programa de inicio de sesión.

784
00:46:13,000 --> 00:46:20,440
Así que este programa de inicio de sesión que usted escribió,
por lo que, obviamente, usted es un buen

785
00:46:20,440 --> 00:46:21,210
programador.

786
00:46:21,210 --> 00:46:25,610
No vas a poner cualquier malicioso
si x es igual a es igual a David es impresionante

787
00:46:25,610 --> 00:46:27,860
en el código.

788
00:46:27,860 --> 00:46:31,930
Pero este programa, lo que se hace
utilizar para compilar este programa?

789
00:46:31,930 --> 00:46:34,180
Algo así como Clang.

790
00:46:34,180 --> 00:46:38,460
¿Y qué si la persona que le pasó a
escribir Clang especial revestido en Clang

791
00:46:38,460 --> 00:46:44,310
algo así como, si estoy recopilando la
programa de inicio de sesión, introduzca el código

792
00:46:44,310 --> 00:46:49,720
en el programa de inicio de sesión que dice, si
x es igual a es igual a David es impresionante?

793
00:46:49,720 --> 00:46:59,890
Así que no es del todo todavía, pero tenemos el mismo
emitir aquí, donde Clang, bueno,

794
00:46:59,890 --> 00:47:03,790
miles, si no decenas de miles de
personas, han mirado Clang, tienen

795
00:47:03,790 --> 00:47:07,160
mirado a sus líneas de código, y dijo:
bien, no hay nada malo aquí.

796
00:47:07,160 --> 00:47:10,680
Obviamente, nadie está haciendo
algo tan malévolo.

797
00:47:10,680 --> 00:47:15,780
>> Pero, ¿qué se CLANG sí mismo, como,
¿y si compilo Clang?

798
00:47:15,780 --> 00:47:20,900
¿Qué pasa si tengo algún compilador que
compila Clang que se inserta en Clang

799
00:47:20,900 --> 00:47:25,610
este truco especial que dice, está bien,
cuando compilo Clang, entonces el

800
00:47:25,610 --> 00:47:31,290
ejecutable se produce especialmente debo mirar
dentro del programa de usuario y la inserción

801
00:47:31,290 --> 00:47:34,230
esta contraseña, es igual a los iguales
Dave es impresionante?

802
00:47:34,230 --> 00:47:37,990
Así que recuerde que su propio compilador
necesita ser compilado en algún momento.

803
00:47:37,990 --> 00:47:42,810
Así que si lo que usted elija para compilar Clang
con, sí es dañino, entonces usted

804
00:47:42,810 --> 00:47:45,580
podría ser atornillado el conjunto
camino por la línea.

805
00:47:45,580 --> 00:47:49,630
>> Así que aquí tenemos a Ken Thompson
y Dennis Ritchie.

806
00:47:49,630 --> 00:47:53,780
Así que esta es una foto icónica.

807
00:47:53,780 --> 00:47:55,470
Dennis Ritchie está a la derecha.

808
00:47:55,470 --> 00:47:58,740
Él es uno de los principales -

809
00:47:58,740 --> 00:48:03,640
prácticamente escribió C. Así que usted puede
darle las gracias por esta clase.

810
00:48:03,640 --> 00:48:04,840
Ken Thomson está a la izquierda.

811
00:48:04,840 --> 00:48:07,780
Los dos de ellos, básicamente, escribió UNIX.

812
00:48:07,780 --> 00:48:10,140
Bueno, eran los principales contribuyentes
en UNIX.

813
00:48:10,140 --> 00:48:11,310
Hubo algunos otros.

814
00:48:11,310 --> 00:48:16,240
Así que Ken Thompson, en algún momento,
gana el Premio Turing.

815
00:48:16,240 --> 00:48:20,860
Y el premio Turing, siempre he escuchado
se hace referencia de esta manera, es el

816
00:48:20,860 --> 00:48:23,100
Premio Nobel de la informática.

817
00:48:23,100 --> 00:48:27,500
>> Así que en el Premio Turing, que tiene que
dar su discurso de aceptación.

818
00:48:27,500 --> 00:48:31,790
Y se le da a este muy famoso discurso
Ahora, llamado Reflexiones sobre Confiando

819
00:48:31,790 --> 00:48:35,620
Trust, que hemos vinculado
a en el sitio web del curso.

820
00:48:35,620 --> 00:48:41,670
Y en este discurso, se dice, está bien,
así que escribí UNIX, y ahora todos

821
00:48:41,670 --> 00:48:43,320
que la gente está usando UNIX.

822
00:48:43,320 --> 00:48:46,960
Ahora, recuerda hoy que Linux es
un descendiente directo de UNIX.

823
00:48:46,960 --> 00:48:50,140
OS X utiliza directamente UNIX.

824
00:48:50,140 --> 00:48:53,810
Windows no hace mucho, pero mucho
de ideas fueron tomadas de UNIX.

825
00:48:53,810 --> 00:48:59,220
>> Así que se sube al escenario y dice,
bien, escribí UNIX.

826
00:48:59,220 --> 00:49:03,940
Y para que lo que ustedes saben, yo soy
podrá iniciar sesión en cada

827
00:49:03,940 --> 00:49:05,590
y cada uno de los equipos.

828
00:49:05,590 --> 00:49:14,280
Desde que me puse una de ellas especial si x
es igual a es igual a Ken Thomson es impresionante,

829
00:49:14,280 --> 00:49:16,350
entonces yo estoy autorizado para iniciar sesión.

830
00:49:16,350 --> 00:49:18,370
Así que las personas son como, bueno,
¿Cómo hiciste eso?

831
00:49:18,370 --> 00:49:21,090
Nos fijamos en el programa de inicio de sesión
y nada está allí.

832
00:49:21,090 --> 00:49:24,700
Es como, bueno, he modificado el compilador
para ingresar en el programa de inicio de sesión

833
00:49:24,700 --> 00:49:30,490
para que el programa de inicio de sesión tendrá ahora
que x es igual a es igual a Ken Thompson

834
00:49:30,490 --> 00:49:31,700
es impresionante.

835
00:49:31,700 --> 00:49:33,120
>> Y dicen, bueno, eso no es cierto.

836
00:49:33,120 --> 00:49:35,740
Estamos pensando en el compilador y el
compilador no tiene líneas de

837
00:49:35,740 --> 00:49:36,400
código de esa manera.

838
00:49:36,400 --> 00:49:40,540
Es como, OK, pero ¿cuáles son usted
compilar el compilador?

839
00:49:40,540 --> 00:49:44,810
Y piensan, y él es, como, bueno,
Yo soy el que te dio el compilador

840
00:49:44,810 --> 00:49:50,580
está utilizando para compilar el compilador, por lo
está compilando un compilador, que

841
00:49:50,580 --> 00:49:56,390
sí es malicioso, y la voluntad
romper el programa de inicio de sesión.

842
00:49:56,390 --> 00:49:59,360
Así que, básicamente, en ese momento, no hay
de ninguna manera se puede mirar en la fuente

843
00:49:59,360 --> 00:50:02,450
código del programa de inicio de sesión
para ver lo que está mal.

844
00:50:02,450 --> 00:50:04,220
Ni siquiera se podía mirar en la
código fuente del compilador

845
00:50:04,220 --> 00:50:06,790
para ver lo que está mal.

846
00:50:06,790 --> 00:50:11,940
>> Usted tendría que mirar a la máquina
código, el binario real de la

847
00:50:11,940 --> 00:50:16,760
compilador compilado para ver, espera, éstos
líneas de código no deberían estar aquí.

848
00:50:16,760 --> 00:50:22,130
Pero Ken Thompson llevó un paso
más allá y dijo, bueno, hay

849
00:50:22,130 --> 00:50:25,980
estos programas especiales que en realidad
ayudará a leer el binario de los programas,

850
00:50:25,980 --> 00:50:29,340
y por lo que si alguien utiliza ese programa para
leer el binario, verían estos

851
00:50:29,340 --> 00:50:30,490
líneas de código.

852
00:50:30,490 --> 00:50:34,020
Modificó los programas que decir, todo
Está bien, si usted está buscando en la

853
00:50:34,020 --> 00:50:38,460
compilador, no muestran este particular,
conjunto de binario.

854
00:50:38,460 --> 00:50:42,830
>> Así entonces usted necesita para tomar ese paso
más allá y que, básicamente, que podría tener

855
00:50:42,830 --> 00:50:46,210
múltiples niveles de indirección tomadas,
y en algún momento, nadie en realidad

856
00:50:46,210 --> 00:50:47,990
va a ser la comprobación.

857
00:50:47,990 --> 00:50:52,590
Así que la moraleja de la historia es, eres
No voy a estar escribiendo

858
00:50:52,590 --> 00:50:54,340
Clang en esta clase.

859
00:50:54,340 --> 00:50:57,020
Usted va a estar usando la escalada
Clang mucho en esta clase.

860
00:50:57,020 --> 00:51:00,490
Para todos ustedes saben, Clang es un malicioso
programa que está saboteando cada

861
00:51:00,490 --> 00:51:03,520
solo programa alguna vez has compilado.

862
00:51:03,520 --> 00:51:08,206
Y para salir de ese mismo siniestro
nota, nos vemos el miércoles.

863
00:51:08,206 --> 00:51:10,030
>> [Aplausos]

864
00:51:10,030 --> 00:51:12,935
>> ALTAVOZ 2: En la siguiente CS50.

865
00:51:12,935 --> 00:51:14,580
>> ALTAVOZ 3: No te atrevas a decir eso.

866
00:51:14,580 --> 00:51:15,930
Usted puede hacer esto.

867
00:51:15,930 --> 00:51:19,440
Usted ha hecho esto antes, usted puede hacer esto
hoy en día, usted puede hacer esto mañana.

868
00:51:19,440 --> 00:51:20,930
Has estado haciendo esto durante años.

869
00:51:20,930 --> 00:51:22,790
Sólo tienes que ir allí y hacerlo.

870
00:51:22,790 --> 00:51:24,310
Usted puede hacer esto.

871
00:51:24,310 --> 00:51:26,102
>> [REPRODUCCIÓN DE MÚSICA]