1
00:00:00,000 --> 00:00:00,309

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS:?] Hola,
Estoy [? Dan Armadaras?].

3
00:00:02,350 --> 00:00:04,410
Hoy, vamos a
se busca en la depuración.

4
00:00:04,410 --> 00:00:06,697
No sólo vamos a
hablar de algunas técnicas,

5
00:00:06,697 --> 00:00:09,280
sino que también vamos a mirar
algunas de las características contenidas

6
00:00:09,280 --> 00:00:14,170
dentro del IDE CS50 que permiten
depurar fácilmente un programa.

7
00:00:14,170 --> 00:00:16,272
>> Sólo un ejemplo de
algo que puede salir mal

8
00:00:16,272 --> 00:00:18,730
y de hecho es algo
que ya hemos visto antes.

9
00:00:18,730 --> 00:00:23,200
En este caso, este es un programa C
que acepta un número entero de usuario,

10
00:00:23,200 --> 00:00:27,580
lo divide por dos, y proporciona
la salida de nuevo al usuario.

11
00:00:27,580 --> 00:00:30,610
Ahora de lo que hemos visto
anteriormente en conferencias,

12
00:00:30,610 --> 00:00:34,370
sabemos que esto va a causar
tipos específicos de problemas de división

13
00:00:34,370 --> 00:00:35,860
cuando tenemos números impares.

14
00:00:35,860 --> 00:00:40,330
>> En concreto, sólo tendremos que tiramos
nada después de la coma decimal.

15
00:00:40,330 --> 00:00:43,170
Ahora, sabemos que este
pasa a ser el caso.

16
00:00:43,170 --> 00:00:47,430
Y si corremos, podemos confirmar
nuestras sospechas, primero, por la compilación.

17
00:00:47,430 --> 00:00:50,460
Y luego, corriendo y
entrar en un número impar.

18
00:00:50,460 --> 00:00:51,720
>> Esto no es nada nuevo.

19
00:00:51,720 --> 00:00:54,490
Pero esto es en realidad un
ejemplo de un error que

20
00:00:54,490 --> 00:00:58,810
puede existir dentro de un programa más amplio
que se convierte en más difícil de rastrear.

21
00:00:58,810 --> 00:01:02,640
A pesar de que sabemos cuál es el problema
es decir, el verdadero quid de la cuestión

22
00:01:02,640 --> 00:01:06,250
podría tratar de identificar
específicamente donde se produce el error,

23
00:01:06,250 --> 00:01:09,750
identificar lo que ese problema
es, y luego arreglarlo.

24
00:01:09,750 --> 00:01:14,400
Así que ofrecer esto como un ejemplo
de lo que podría ser algo

25
00:01:14,400 --> 00:01:19,030
que ya sabemos, pero puede ser enterrado
dentro de otros elementos del código.

26
00:01:19,030 --> 00:01:23,090
>> Por lo tanto la apertura de esta otra fuente
archivo de código como un ejemplo,

27
00:01:23,090 --> 00:01:27,165
este problema de división es ahora
parte de un programa más amplio.

28
00:01:27,165 --> 00:01:29,040
Aún podría ser un poco
poco artificial, y nosotros

29
00:01:29,040 --> 00:01:31,076
podría ser capaz de facilidad
identificarlo, especialmente

30
00:01:31,076 --> 00:01:32,450
ya que sólo estamos discutiendo esto.

31
00:01:32,450 --> 00:01:38,250
Pero podemos imaginar que esta
problema puede existir en una escala más grande.

32
00:01:38,250 --> 00:01:45,450
>> Si compilo esto y ahora
ejecutarlo, introduzca un número impar,

33
00:01:45,450 --> 00:01:49,816
podemos ver que no obtenemos precisamente
la salida que podemos haber esperado.

34
00:01:49,816 --> 00:01:51,690
En este caso particular,
podríamos decir que nos

35
00:01:51,690 --> 00:01:56,060
quieren contar todos los números
desde uno hasta algún número específico.

36
00:01:56,060 --> 00:01:58,130
Y podemos ver que
tener una variedad de temas

37
00:01:58,130 --> 00:02:03,880
aquí si estamos salida, simplemente, 0
y 1 cuando proporcionamos una entrada de 5.

38
00:02:03,880 --> 00:02:07,380
>> Así que ya sabemos que
hay un problema aquí.

39
00:02:07,380 --> 00:02:11,662
Pero no podemos saber con precisión
donde este problema realmente existe.

40
00:02:11,662 --> 00:02:13,620
Ahora una de las formas en que
podemos tratar de solucionar este problema

41
00:02:13,620 --> 00:02:15,745
es algo que hemos
ya se ha introducido a.

42
00:02:15,745 --> 00:02:18,880
Sólo podemos usarlo en una escala más grande.

43
00:02:18,880 --> 00:02:21,680
>> En la línea 14, que tenemos
esta función printf,

44
00:02:21,680 --> 00:02:25,620
lo que nos permite imprimir el estado
de varias piezas de información.

45
00:02:25,620 --> 00:02:28,880
Y esto es algo que usted
debe aprovechar dentro de su programa

46
00:02:28,880 --> 00:02:33,100
para tratar de averiguar exactamente lo que es
sucediendo en diversas líneas de código.

47
00:02:33,100 --> 00:02:36,350
Así que incluso si este no es el
salida final que en realidad

48
00:02:36,350 --> 00:02:39,830
querer producir de
este programa, todavía

49
00:02:39,830 --> 00:02:42,300
podrían tener cierta depuración
declaraciones donde nos

50
00:02:42,300 --> 00:02:46,970
puede tratar de averiguar exactamente lo
que está sucediendo dentro de nuestro código.

51
00:02:46,970 --> 00:02:51,210
>> Así que en este caso, lo haré
printf con la etiqueta de depuración.

52
00:02:51,210 --> 00:02:53,540
En este caso, esto es
sólo una cadena de depuración

53
00:02:53,540 --> 00:02:56,840
que estoy hasta desagradable para que se convierta
muy claro en la salida de mi código

54
00:02:56,840 --> 00:02:59,200
qué es lo que quiero mostrar.

55
00:02:59,200 --> 00:03:04,410
Y aquí el número de salida
que hemos calculado.

56
00:03:04,410 --> 00:03:06,800
>> En este caso, podría
diga de forma precisa

57
00:03:06,800 --> 00:03:11,380
lo que está ocurriendo antes y
después de un cálculo específico.

58
00:03:11,380 --> 00:03:16,224
Así que yo podría utilizar un printf antes
y después de esa línea de código.

59
00:03:16,224 --> 00:03:18,640
En este caso, podría incluso
que sea un poco más clara

60
00:03:18,640 --> 00:03:21,960
diciendo depuración antes
y depuración después de tanto

61
00:03:21,960 --> 00:03:26,540
que yo no confundo a mí mismo con
múltiples líneas que parecen idénticos.

62
00:03:26,540 --> 00:03:32,290
>> Ahora bien, si a compilar y ejecutar este
ella, entrar un número como de cinco más,

63
00:03:32,290 --> 00:03:35,090
podemos ver que tenemos
ahora de salida antes y después de

64
00:03:35,090 --> 00:03:40,670
y encontramos que no hemos hecho una clara
división o transparente que tiene el número

65
00:03:40,670 --> 00:03:43,680
que en realidad queremos hacer.

66
00:03:43,680 --> 00:03:48,660
Ahora bien, en este caso, se trata de
no es realmente una salida clara.

67
00:03:48,660 --> 00:03:52,440
En realidad no es un resultado claro que
queremos salir de este programa en particular.

68
00:03:52,440 --> 00:03:54,427
>> Y esto es, de nuevo, un
poco artificial.

69
00:03:54,427 --> 00:03:57,510
Pero, tal vez, una de las cosas que
que podríamos hacer si la especificación dijo

70
00:03:57,510 --> 00:04:01,900
que queremos dividir esto
2 y añadir 1-- por lo que en otras palabras,

71
00:04:01,900 --> 00:04:04,550
queremos redondear up-- continuación
podríamos saber que pudimos

72
00:04:04,550 --> 00:04:08,060
hacer esa cosa en particular, en este caso.

73
00:04:08,060 --> 00:04:14,010
Ahora, aquí sabemos que seremos
capaz de sumar 1 a nuestro número reducido a la mitad.

74
00:04:14,010 --> 00:04:16,490
>> Vamos a recompilar este
y confirmar que esta

75
00:04:16,490 --> 00:04:18,860
se comporta de la manera que queremos.

76
00:04:18,860 --> 00:04:21,980
Podemos ver que ahora antes de que
tener, tenemos el número 5.

77
00:04:21,980 --> 00:04:26,620
Después de tener, tenemos el número 3,
que de acuerdo con nuestra especificación,

78
00:04:26,620 --> 00:04:29,292
es lo que queríamos hacer.

79
00:04:29,292 --> 00:04:31,000
Pero si nos fijamos en el
salida de aquí, podemos

80
00:04:31,000 --> 00:04:33,760
ver que podríamos tener otra
bug por completo, que es

81
00:04:33,760 --> 00:04:36,940
que estamos empezando nuestra cuenta desde 0.

82
00:04:36,940 --> 00:04:39,390
>> Ahora, de nuevo, esto es algo
que hemos visto en el pasado

83
00:04:39,390 --> 00:04:42,500
y podemos fijar con bastante facilidad.

84
00:04:42,500 --> 00:04:44,790
Pero en este caso,
También tenía la ventaja

85
00:04:44,790 --> 00:04:48,940
de utilizar la instrucción printf
directamente en el interior del bucle for

86
00:04:48,940 --> 00:04:52,930
saber con precisión dónde
que el error estaba ocurriendo.

87
00:04:52,930 --> 00:04:55,150
Declaraciones Así printf son
muy útil para ayudar

88
00:04:55,150 --> 00:04:57,940
a determinar dónde,
precisamente en su código fuente,

89
00:04:57,940 --> 00:05:00,620
se está produciendo un error específico.

90
00:05:00,620 --> 00:05:03,650
>> Y también es importante tener en cuenta
que, como estamos escribiendo código,

91
00:05:03,650 --> 00:05:06,052
podríamos tener supuestos
sobre el estado de un programa.

92
00:05:06,052 --> 00:05:08,510
O puede ser que tengamos supuestos
sobre qué parte del programa

93
00:05:08,510 --> 00:05:13,020
es realmente correcto o incorrecto cuando
más adelante a medida que construimos en ese programa

94
00:05:13,020 --> 00:05:15,950
y que sea parte de un
complejo y más grande programa

95
00:05:15,950 --> 00:05:19,700
que nos damos cuenta de que algún aspecto
de que es en realidad buggy.

96
00:05:19,700 --> 00:05:22,680
>> El uso de printf realmente puede ayudar
delimitar e identificar

97
00:05:22,680 --> 00:05:26,430
las regiones de un programa que no puede
se comporta exactamente de la manera que nosotros

98
00:05:26,430 --> 00:05:29,500
esperar que, con base en nuestras suposiciones.

99
00:05:29,500 --> 00:05:31,460
Pero hay otras herramientas
disponibles, así,

100
00:05:31,460 --> 00:05:34,860
que nos permiten tratar de entender
dónde se está produciendo un error

101
00:05:34,860 --> 00:05:39,930
y también, específicamente, qué cosas
están sucediendo dentro del programa.

102
00:05:39,930 --> 00:05:41,990
>> Así que usando printf es muy
cuando queremos útil

103
00:05:41,990 --> 00:05:45,900
para identificar las áreas específicas de
un programa que tiene algunos errores.

104
00:05:45,900 --> 00:05:47,730
Pero también se convierte
aburrido después de un tiempo.

105
00:05:47,730 --> 00:05:50,500
En este caso, se trata de una
programa relativamente simple

106
00:05:50,500 --> 00:05:52,750
con sólo una o dos variables.

107
00:05:52,750 --> 00:05:57,260
Y se hace muy fácil para nosotros
imprimir el valor de esas variables

108
00:05:57,260 --> 00:05:59,670
en el contexto del programa más grande.

109
00:05:59,670 --> 00:06:02,670
>> Pero podríamos tener un diferente
programa que tiene muchas variables.

110
00:06:02,670 --> 00:06:06,530
Y puede no ser bastante
tan fácil de usar printf

111
00:06:06,530 --> 00:06:10,120
para tratar de evaluar lo que está sucediendo
a cada una de esas variables

112
00:06:10,120 --> 00:06:13,590
ya que el programa se está ejecutando.

113
00:06:13,590 --> 00:06:16,960
Hay un programa que existe
llamado un programa depurador.

114
00:06:16,960 --> 00:06:20,320
En este caso, el que lo haremos
uso es el depurador de GNU, o GDB,

115
00:06:20,320 --> 00:06:24,260
que nos permite inspeccionar el interior
funcionamiento de un programa en una forma mucho más

116
00:06:24,260 --> 00:06:25,700
manera detallada.

117
00:06:25,700 --> 00:06:28,810
>> De hecho, podemos ejecutar
BGF desde la línea de comandos

118
00:06:28,810 --> 00:06:35,370
aquí simplemente escribiendo el BGF y la
comandos que queremos depurar.

119
00:06:35,370 --> 00:06:37,550
En este caso, contar.

120
00:06:37,550 --> 00:06:41,650
Ahora bien, en este caso, podemos ver que
nos lleva a un mensaje que dice GDB.

121
00:06:41,650 --> 00:06:44,020
Y podemos realidad
ejecutar comandos de GDB

122
00:06:44,020 --> 00:06:48,260
para comenzar realmente la ejecución de la
programa, detenerlo en ciertos puntos,

123
00:06:48,260 --> 00:06:51,060
evaluar las variables y
inspeccionar las variables que

124
00:06:51,060 --> 00:06:54,152
existir en el estado del programa
en ese momento particular,

125
00:06:54,152 --> 00:06:55,110
y así sucesivamente y así sucesivamente.

126
00:06:55,110 --> 00:06:57,240
Proporciona una gran cantidad de energía para nosotros.

127
00:06:57,240 --> 00:06:59,960
>> Pero da la casualidad
que el IDE CS50 también

128
00:06:59,960 --> 00:07:05,870
proporciona una interfaz gráfica de usuario o de un usuario
interfaz para que GDB

129
00:07:05,870 --> 00:07:11,120
nos permite hacer esto sin necesidad
la interfaz de línea de comandos en absoluto

130
00:07:11,120 --> 00:07:13,560
o en todo incluso.

131
00:07:13,560 --> 00:07:16,930
La forma en que yo pueda acceder a esa
es mediante el botón de depuración

132
00:07:16,930 --> 00:07:20,120
en la parte superior del IDE CS50.

133
00:07:20,120 --> 00:07:24,280
Ahora bien, en el pasado, lo que tenemos
visto es que usamos el comando

134
00:07:24,280 --> 00:07:27,660
line para compilar y ejecutar un programa.

135
00:07:27,660 --> 00:07:29,790
>> El botón de depuración hace
ambos de esos pasos.

136
00:07:29,790 --> 00:07:34,380
Pero también se abre la
pestaña depurador en el extremo derecho

137
00:07:34,380 --> 00:07:38,280
que nos permite inspeccionar una variedad
de las propiedades del programa

138
00:07:38,280 --> 00:07:40,500
ya que se está ejecutando.

139
00:07:40,500 --> 00:07:44,280
Si hago clic depuración, en este
caso, se abrirá

140
00:07:44,280 --> 00:07:48,230
una nueva pestaña en la consola
ventana en la parte inferior.

141
00:07:48,230 --> 00:07:51,160
>> Y se puede ver que esta ficha tiene
algo de información en la parte superior.

142
00:07:51,160 --> 00:07:52,670
Y podemos ignorar en gran medida esto.

143
00:07:52,670 --> 00:07:54,800
Pero una de las cosas
que queremos notar

144
00:07:54,800 --> 00:07:57,170
es que emite
lo mismo que nosotros

145
00:07:57,170 --> 00:08:03,000
obtendría si tratamos de hacer funcionar el
el programa de C en la ventana de terminal.

146
00:08:03,000 --> 00:08:06,230
>> Aquí, podemos ver que se está ejecutando sonido metálico,
y tiene una variedad de banderas,

147
00:08:06,230 --> 00:08:12,660
y se está recopilando nuestro archivo count.c,
que fue la ficha seleccionada en el momento

148
00:08:12,660 --> 00:08:15,100
que me golpeó de depuración.

149
00:08:15,100 --> 00:08:18,010
Así que esto es muy útil porque
ahora con este botón de depuración,

150
00:08:18,010 --> 00:08:23,280
podemos recopilar de forma simultánea y después
ejecutar el programa que en realidad

151
00:08:23,280 --> 00:08:24,460
que desee ejecutar.

152
00:08:24,460 --> 00:08:27,880
>> Uno de los indicadores que se
importante, en este caso,

153
00:08:27,880 --> 00:08:30,190
que en realidad hemos estado usando
para el tiempo más largo

154
00:08:30,190 --> 00:08:32,450
sino que también acaba de hacer un poco de la mano
agitando [inaudible], que

155
00:08:32,450 --> 00:08:33,820
es esta de aquí.

156
00:08:33,820 --> 00:08:35,790
En clang, dice -ggdb3.

157
00:08:35,790 --> 00:08:38,570

158
00:08:38,570 --> 00:08:41,250
En este caso, lo que somos
diciendo sonido metálico, nuestro compilador,

159
00:08:41,250 --> 00:08:43,820
es que queremos compilar nuestro programa.

160
00:08:43,820 --> 00:08:46,810
Pero también proporcionar lo que son
llamada información de símbolos

161
00:08:46,810 --> 00:08:50,940
para que el compilador en realidad tiene acceso
a una gran cantidad de la información subyacente

162
00:08:50,940 --> 00:08:52,610
contenida dentro del programa.

163
00:08:52,610 --> 00:08:55,260
>> Más específicamente, el número
de las funciones que tengo,

164
00:08:55,260 --> 00:08:58,000
los nombres de las funciones,
las variables, los tipos

165
00:08:58,000 --> 00:09:01,730
que esas variables son, y una variedad
de otras cosas que ayudan a que el depurador

166
00:09:01,730 --> 00:09:04,350
realizar su operación.

167
00:09:04,350 --> 00:09:06,600
Ahora hay algo más
eso es importante mencionar

168
00:09:06,600 --> 00:09:10,280
cuando estamos discutiendo en ejecución
un programa de esta manera.

169
00:09:10,280 --> 00:09:13,660
>> Observe que no tiene realidad
criado una nueva pestaña en nuestra consola

170
00:09:13,660 --> 00:09:14,780
a lo largo de la parte inferior.

171
00:09:14,780 --> 00:09:18,600
Ya no tenemos que interactuar
directamente con la ventana de terminal.

172
00:09:18,600 --> 00:09:21,420
Pero esta nueva pestaña es
en realidad una ventana de terminal.

173
00:09:21,420 --> 00:09:26,710
Sólo es específico para el funcionamiento
programa que hemos creado.

174
00:09:26,710 --> 00:09:29,270
>> Observe que en la parte inferior, en
combinación con alguna salida

175
00:09:29,270 --> 00:09:33,500
por clang el compilador y el BGF,
que podemos ignorar en gran medida,

176
00:09:33,500 --> 00:09:37,570
que en realidad muestra la salida de
nuestro programa en la parte inferior.

177
00:09:37,570 --> 00:09:41,240
Ahora es importante tener en cuenta
que esta en realidad una ventana

178
00:09:41,240 --> 00:09:43,360
le mostrará la
salida de su programa

179
00:09:43,360 --> 00:09:47,190
pero también puede aceptar la entrada
para ese programa, también.

180
00:09:47,190 --> 00:09:49,260
>> Así nota que indica
Por favor, introduzca un número,

181
00:09:49,260 --> 00:09:53,050
que es la misma salida que teníamos
tenía en la ventana de terminal antes.

182
00:09:53,050 --> 00:09:55,510
Pero se muestra ahora en esta nueva pestaña.

183
00:09:55,510 --> 00:09:56,550
Me puede introducir un número.

184
00:09:56,550 --> 00:10:00,900
Y lo hará realidad
función que esperamos

185
00:10:00,900 --> 00:10:05,890
mostrándonos nuestra depuración, la producción,
la salida que podría ser con errores,

186
00:10:05,890 --> 00:10:07,010
como hemos visto antes.

187
00:10:07,010 --> 00:10:10,460
Y en la parte inferior, se
en realidad tiene una salida adicional

188
00:10:10,460 --> 00:10:14,550
del PIB sólo decir que
este programa se ha completado.

189
00:10:14,550 --> 00:10:16,655
>> Ahora bien, como se vio en este
en particular carrera a través de,

190
00:10:16,655 --> 00:10:19,370
no era particularmente
útil porque incluso

191
00:10:19,370 --> 00:10:23,740
a pesar de que había llegado el menú depurador
arriba, esto era todavía un programa en ejecución.

192
00:10:23,740 --> 00:10:26,790
En ningún momento hizo realidad
detener la ejecución para nosotros

193
00:10:26,790 --> 00:10:30,767
ser capaz de inspeccionar todos
las variables contenidas dentro.

194
00:10:30,767 --> 00:10:32,850
Hay algo más
que tenemos que hacer para

195
00:10:32,850 --> 00:10:36,910
para obtener GDB reconocer que queremos
para detener la ejecución del programa

196
00:10:36,910 --> 00:10:42,820
y no sólo permitir que se proceda
normalmente como lo haríamos en cualquier otro caso.

197
00:10:42,820 --> 00:10:45,530
>> Con el fin de detener la ejecución,
en algún línea específica,

198
00:10:45,530 --> 00:10:47,830
tenemos que crear lo que es
llamado un punto de quiebre.

199
00:10:47,830 --> 00:10:52,670
Y un punto de quiebre se crea con mucha facilidad
en este CS50 IDE tomando el puntero del ratón

200
00:10:52,670 --> 00:10:57,090
y haciendo clic directamente a la izquierda
de un número de línea específico.

201
00:10:57,090 --> 00:10:59,920
Una vez que lo hago, un punto rojo
aparece, que indica

202
00:10:59,920 --> 00:11:02,300
que esa línea es ahora un punto de quiebre.

203
00:11:02,300 --> 00:11:07,540
>> Y la próxima vez que corro GDB, que
se detendrá la ejecución en ese punto de ruptura

204
00:11:07,540 --> 00:11:10,280
cuando llega a esa línea de código.

205
00:11:10,280 --> 00:11:12,230
Ahora bien, este es un importante
es darse cuenta

206
00:11:12,230 --> 00:11:16,140
que no es necesariamente el
caso de que cada línea de código

207
00:11:16,140 --> 00:11:17,880
es realmente accesible.

208
00:11:17,880 --> 00:11:23,780
Si tuviera que crear una función
aquí, por ejemplo-- vacío F--

209
00:11:23,780 --> 00:11:31,230
y acaba de hacer una línea de impresión aquí-- hola
mundo-- si no vuelvo a llamar a esta función,

210
00:11:31,230 --> 00:11:34,770
será el caso de que,
si me puse un punto de descanso aquí,

211
00:11:34,770 --> 00:11:36,220
la función nunca se llamará.

212
00:11:36,220 --> 00:11:38,310
Y por lo tanto, este
en particular punto de quiebre

213
00:11:38,310 --> 00:11:43,040
será en realidad nunca hacer una pausa
ejecución del programa.

214
00:11:43,040 --> 00:11:48,020
>> Así que digamos que yo creo correctamente
un punto de quiebre en alguna línea de código

215
00:11:48,020 --> 00:11:50,340
que realmente se ejecuta.

216
00:11:50,340 --> 00:11:53,470
Ahora bien, en este caso, este es el
primera línea de la función principal.

217
00:11:53,470 --> 00:11:56,630
Así que sin duda será el caso
que, tan pronto como empiezo ejecución,

218
00:11:56,630 --> 00:11:58,580
se llegará a la primera línea.

219
00:11:58,580 --> 00:12:00,230
GDB se detendrá la ejecución.

220
00:12:00,230 --> 00:12:04,100
Y luego, voy a ser capaz de
interactuar con el depurador.

221
00:12:04,100 --> 00:12:08,480
>> Puede establecer varias líneas como
puntos de ruptura, si usted desea.

222
00:12:08,480 --> 00:12:11,365
También podemos crear una línea hacia arriba
aquí en este segmento de código

223
00:12:11,365 --> 00:12:12,490
eso nunca se alcanzará.

224
00:12:12,490 --> 00:12:14,744
Y también podemos establecer uno más adelante.

225
00:12:14,744 --> 00:12:16,660
La razón de que lo haríamos
querer hacer esto vamos a

226
00:12:16,660 --> 00:12:19,119
entrar en un poco más
detalle en un momento.

227
00:12:19,119 --> 00:12:21,660
Así que por ahora, permítanme inhabilito
estos puntos de quiebre adicionales

228
00:12:21,660 --> 00:12:24,940
para que podamos ver lo que sucede
cuando tengo una sola ruptura

229
00:12:24,940 --> 00:12:27,650
punto de mi programa.

230
00:12:27,650 --> 00:12:29,410
He hecho algunos
cambios en este programa.

231
00:12:29,410 --> 00:12:30,750
Así que tengo que guardarlo.

232
00:12:30,750 --> 00:12:34,490
Voy a hacer clic de depuración para que yo pueda
comenzar la compilación y después

233
00:12:34,490 --> 00:12:36,880
ejecución del depurador.

234
00:12:36,880 --> 00:12:40,632
>> Vamos a ver que, después de momentos, los
línea que hemos seleccionado como el descanso

235
00:12:40,632 --> 00:12:43,360
punto se resalta en amarillo.

236
00:12:43,360 --> 00:12:47,440
También podemos notar que en el
superior derecha del panel de depuración

237
00:12:47,440 --> 00:12:50,940
de que el icono de pausa se ha convertido
en un pequeño icono de reproducción.

238
00:12:50,940 --> 00:12:54,710
Esto significa que tenemos que hacer una pausa
ejecución, en este caso particular.

239
00:12:54,710 --> 00:12:57,840
Y golpear el botón de reproducción se
nos permite reanudar la ejecución

240
00:12:57,840 --> 00:13:00,000
en ese punto específico.

241
00:13:00,000 --> 00:13:03,240
>> Observe que hay un par de otros
botones disponibles en este panel de depuración,

242
00:13:03,240 --> 00:13:04,220
así como.

243
00:13:04,220 --> 00:13:09,470
Pasar por encima, lo que me permite
ejecutar que una línea de código

244
00:13:09,470 --> 00:13:14,030
y pasar por encima de esa línea a la
siguiente, que, en este caso,

245
00:13:14,030 --> 00:13:17,060
que significaría que el printf
se ejecuta comunicado.

246
00:13:17,060 --> 00:13:22,310
Y a continuación, hará una pausa
la ejecución de la línea 13, como tal.

247
00:13:22,310 --> 00:13:25,090
>> Y hay también un paso
en función, que

248
00:13:25,090 --> 00:13:28,950
es útil si he creado otra
funciones en el código fuente en otros lugares.

249
00:13:28,950 --> 00:13:31,420
Y quiero entrar en
esas funciones en lugar de

250
00:13:31,420 --> 00:13:33,050
ejecutar esa función como un todo.

251
00:13:33,050 --> 00:13:37,279
Pero vamos a ver más en el paso
en función en un momento.

252
00:13:37,279 --> 00:13:40,320
Ahora note algunas otras cosas que
realmente existir dentro de este panel de depuración.

253
00:13:40,320 --> 00:13:44,110
>> Tenemos este panel llamado
Pila de llamadas, lo que nos muestra

254
00:13:44,110 --> 00:13:45,300
dónde exactamente que somos.

255
00:13:45,300 --> 00:13:48,550
En este caso, estamos dentro
de la función principal.

256
00:13:48,550 --> 00:13:50,880
Nuestro script se llama count.c.

257
00:13:50,880 --> 00:13:53,820
Y nos toca estar en
línea 13, columna uno, que

258
00:13:53,820 --> 00:13:58,950
es precisamente lo que la región resaltada
del código fuente indica, también.

259
00:13:58,950 --> 00:14:02,435
>> Ahora note que esto demuestra también
en la sección variable local

260
00:14:02,435 --> 00:14:06,710
todas las variables que
existir dentro de esta función.

261
00:14:06,710 --> 00:14:08,930
Es importante tener en cuenta
que todas las variables

262
00:14:08,930 --> 00:14:12,580
aparecerá en esta variable local
sección dentro de una función,

263
00:14:12,580 --> 00:14:14,380
incluso antes de que se definen.

264
00:14:14,380 --> 00:14:19,160
Podemos ver aquí que tenemos una variable
llamada num, tiene un valor predeterminado de 0,

265
00:14:19,160 --> 00:14:21,280
y es de tipo int.

266
00:14:21,280 --> 00:14:24,110
>> Ahora antes de que realmente inicializamos
todas estas variables,

267
00:14:24,110 --> 00:14:26,685
no estamos necesariamente
garantizado para ver un valor de 0.

268
00:14:26,685 --> 00:14:29,200
Y dependiendo de otras ejecuciones
que ha realizado

269
00:14:29,200 --> 00:14:32,020
y el estado de su memoria cuando
en realidad se ejecuta este programa,

270
00:14:32,020 --> 00:14:34,605
usted podría encontrar que usted
no ven los valores de 0

271
00:14:34,605 --> 00:14:36,550
y, en cambio, algunos otros números de locos.

272
00:14:36,550 --> 00:14:38,390
>> Pero no te preocupes por eso.

273
00:14:38,390 --> 00:14:44,610
No va a ser relevante hasta
que realmente inicializar el valor.

274
00:14:44,610 --> 00:14:49,630
Ahora bien, en este caso, podemos ver que
He realizado algunas salidas.

275
00:14:49,630 --> 00:14:52,131
Y estoy, ahora mismo, detuve la ejecución.

276
00:14:52,131 --> 00:14:53,880
Pero en este caso, lo
Tengo muchas ganas de hacer

277
00:14:53,880 --> 00:14:58,060
es dar un paso ahora sobre esta línea
de código para que pueda realmente

278
00:14:58,060 --> 00:15:04,390
consultar el usuario para ese int que
queremos utilizar en nuestro programa.

279
00:15:04,390 --> 00:15:07,060
>> Ahora bien, en este caso, cuando
Golpeé pasar por encima, previo aviso

280
00:15:07,060 --> 00:15:11,940
que la pausa o más bien la reanudación
botón ha cambiado a este botón Pausa

281
00:15:11,940 --> 00:15:14,022
ya que este código se ejecuta en realidad.

282
00:15:14,022 --> 00:15:15,730
Que esta pasando
en este momento es que se trata

283
00:15:15,730 --> 00:15:21,630
esperando por nosotros para introducir alguna información
como podemos ver por nuestro texto de salida

284
00:15:21,630 --> 00:15:23,600
en la parte inferior.

285
00:15:23,600 --> 00:15:25,787
>> Así que ahora mismo, esto es
en realidad no se detuvo,

286
00:15:25,787 --> 00:15:28,620
a pesar de que, en cierto modo, parece
ser porque nada está sucediendo.

287
00:15:28,620 --> 00:15:32,360
Pero da la casualidad de que en
mi caso concreto en la línea 13,

288
00:15:32,360 --> 00:15:34,210
Estoy esperando a la entrada del usuario.

289
00:15:34,210 --> 00:15:39,130
Y así BGF no es capaz de inspeccionar
un programa a medida que se está ejecutando.

290
00:15:39,130 --> 00:15:43,370
>> Ahora, la próxima vez que entro en alguna
input-- así que voy a entrar en ese número 5,

291
00:15:43,370 --> 00:15:46,140
como hemos visto en el
past-- pulsa Intro, y nosotros

292
00:15:46,140 --> 00:15:51,430
notar que, inmediatamente, pausas GDB
y, de nuevo, se destaca la siguiente línea.

293
00:15:51,430 --> 00:15:55,320
Pero nótese que ahora, como un
resultado de nuestra ingresar un valor,

294
00:15:55,320 --> 00:15:58,930
hemos actualizado ese valor en el interior
de nuestras variables locales, que

295
00:15:58,930 --> 00:16:05,560
es muy útil saber con precisión
lo que ese número era en la memoria.

296
00:16:05,560 --> 00:16:10,650
>> Ahora puedo permitir que este programa continúe
jugando hasta el final de su ejecución

297
00:16:10,650 --> 00:16:12,570
pulsando Reanudar.

298
00:16:12,570 --> 00:16:16,410
Podemos ver que muy rápidamente
hace el acabado programa en ejecución

299
00:16:16,410 --> 00:16:19,790
con la misma salida que nos
tenido antes, el depurador se cierra,

300
00:16:19,790 --> 00:16:23,170
y ahora este programa
se ha detenido por completo.

301
00:16:23,170 --> 00:16:25,320
>> Muestro que sólo para el
efectos de ver lo que

302
00:16:25,320 --> 00:16:27,280
que sucede cuando en realidad nos golpeamos Reanudar.

303
00:16:27,280 --> 00:16:30,640
Pero que en realidad vamos a
quiero volver a este programa

304
00:16:30,640 --> 00:16:33,820
para que podamos tratar de depuración
precisamente lo que está sucediendo.

305
00:16:33,820 --> 00:16:37,980
Ahora que estoy utilizando el depurador, me lo permite
no necesita estas declaraciones de depuración printf.

306
00:16:37,980 --> 00:16:43,860
>> Así que podría eliminarlos como voy a hacer
ahora acaba de regresar a nuestro código más simple

307
00:16:43,860 --> 00:16:45,950
que teníamos hace un momento.

308
00:16:45,950 --> 00:16:48,790
Ahora, cuando me ahorro el
programar y ejecutarlo,

309
00:16:48,790 --> 00:16:53,700
será, de nuevo, ir a esa inicial
romper el punto que yo tenía en la línea 11.

310
00:16:53,700 --> 00:16:57,700
Y voy a ser capaz de inspeccionar
mi variables como lo quieren hacer.

311
00:16:57,700 --> 00:17:00,695
>> Lo que pasa es que esta
parte no es muy interesante,

312
00:17:00,695 --> 00:17:04,364
Y sé que voy
imprimir esta declaración.

313
00:17:04,364 --> 00:17:05,280
Por favor, introduzca un número.

314
00:17:05,280 --> 00:17:08,099
Y luego, sé que voy
preguntar al usuario para ese número entero.

315
00:17:08,099 --> 00:17:13,329
Así que tal vez, yo en realidad quiero mover mi
punto de romper un poco más abajo.

316
00:17:13,329 --> 00:17:16,710
>> Puede eliminar puntos de quiebre
haciendo clic, de nuevo, directamente

317
00:17:16,710 --> 00:17:18,460
a la izquierda de ese número de línea.

318
00:17:18,460 --> 00:17:22,200
Ese punto rojo desaparecerá, indicando
que ese punto de ruptura se ha ido.

319
00:17:22,200 --> 00:17:24,780
Ahora bien, en este caso,
ejecución está en pausa.

320
00:17:24,780 --> 00:17:27,770
Y lo que no es en realidad va a
reanudar en ese caso particular.

321
00:17:27,770 --> 00:17:30,210
Pero puedo configurar un descanso
apuntar un poco más tarde.

322
00:17:30,210 --> 00:17:33,880
>> Y cuando Reanudo ahora mi
código, se reanudará y contar

323
00:17:33,880 --> 00:17:36,190
el punto de que el punto de quiebre.

324
00:17:36,190 --> 00:17:37,374
Una vez más, me golpeó en Reanudar.

325
00:17:37,374 --> 00:17:39,040
No parece nada está sucediendo.

326
00:17:39,040 --> 00:17:41,450
Pero eso es porque mi
código está a la espera para la entrada.

327
00:17:41,450 --> 00:17:47,900
Voy a introducir un número 5, pulse Enter, y
Ahora se dio en el siguiente punto de ruptura.

328
00:17:47,900 --> 00:17:50,570
>> Ahora, en este caso, esta
es la línea de código

329
00:17:50,570 --> 00:17:53,820
que, antes, sabíamos
pasó a ser buggy.

330
00:17:53,820 --> 00:17:57,590
Así que vamos a evaluar lo que sucede
en este punto particular en el tiempo.

331
00:17:57,590 --> 00:18:02,620
Cuando se resalta una línea, esta
línea aún no ha sido ejecutado.

332
00:18:02,620 --> 00:18:06,490
Así que en este caso, podemos ver
que tengo un número, que

333
00:18:06,490 --> 00:18:11,610
Tengo un entero llamado
num que tiene un valor de 5.

334
00:18:11,610 --> 00:18:15,090
Y yo voy a realizar
un poco de matemática en ese número.

335
00:18:15,090 --> 00:18:20,130
>> Si me paso más de eso, podemos
notar que el valor de num

336
00:18:20,130 --> 00:18:23,780
ha cambiado de acuerdo con el
aritmética que realmente hemos hecho.

337
00:18:23,780 --> 00:18:26,810
Y ahora que estamos
dentro de este bucle

338
00:18:26,810 --> 00:18:29,090
o ahora que el bucle for
sí está resaltado,

339
00:18:29,090 --> 00:18:32,450
vemos que tenemos una nueva
variable i llamada que

340
00:18:32,450 --> 00:18:35,370
va a ser utilizado en ese bucle.

341
00:18:35,370 --> 00:18:38,230
>> Ahora recordar antes de que yo
mencionó que a veces eres

342
00:18:38,230 --> 00:18:43,470
ir a ver algún tipo de locura
números como predeterminado antes de ese número

343
00:18:43,470 --> 00:18:45,530
o esa variable es
en realidad inicializado.

344
00:18:45,530 --> 00:18:49,040
Podemos ver que, precisamente,
aquí en la esta variable

345
00:18:49,040 --> 00:18:51,345
llamada i, que no tiene
sin embargo, ha inicializado

346
00:18:51,345 --> 00:18:53,560
en el momento de poner de relieve.

347
00:18:53,560 --> 00:18:57,070
Pero podemos ver que tiene un número
que no íbamos realmente esperar.

348
00:18:57,070 --> 00:18:57,620
>> Eso está bien.

349
00:18:57,620 --> 00:18:59,661
¡No se preocupe
porque tenemos en realidad no

350
00:18:59,661 --> 00:19:04,970
inicializado ese número hasta que
pasar por encima de esta línea y el valor

351
00:19:04,970 --> 00:19:08,560
i ha sido inicializado con el valor 1.

352
00:19:08,560 --> 00:19:11,400
Así que a ver que eso es en realidad
el caso, vamos a pasar por encima.

353
00:19:11,400 --> 00:19:14,420
Ahora podemos ver que ese
línea ha sido ejecutada.

354
00:19:14,420 --> 00:19:17,000
Y ahora estamos destacando
esta línea printf.

355
00:19:17,000 --> 00:19:22,230
>> Y ahora podemos ver cómo nuestros valores
de i y 3 he cambiado con el tiempo.

356
00:19:22,230 --> 00:19:26,450
Esto es muy útil para hacer, de hecho,
es pasar por encima de las líneas en varias ocasiones.

357
00:19:26,450 --> 00:19:30,480
Y usted puede encontrar lo que realmente
que sucede dentro de su bucle for

358
00:19:30,480 --> 00:19:33,660
y lo que le sucede a la
las variables dentro de ese bucle for

359
00:19:33,660 --> 00:19:39,200
como que la ejecución del programa
se produce un paso a la vez.

360
00:19:39,200 --> 00:19:41,110
>> Ahora, en este punto,
pasó por encima de lo justo

361
00:19:41,110 --> 00:19:44,210
que ahora estoy al final de mi programa.

362
00:19:44,210 --> 00:19:46,980
Si me paso más de eso, lo hará
de hecho cesar la ejecución

363
00:19:46,980 --> 00:19:48,860
como hemos visto en el pasado.

364
00:19:48,860 --> 00:19:52,110
Permítanme recomienzo esto, una vez más, por lo que
que puedo señalar algo más,

365
00:19:52,110 --> 00:19:53,320
así como.

366
00:19:53,320 --> 00:19:55,350
>> En este caso, es
ahora me pide, una vez más,

367
00:19:55,350 --> 00:19:57,100
para un número, el cual
Yo, de nuevo, entrar.

368
00:19:57,100 --> 00:20:00,300
Pero esta vez, voy a entrar en
un número más grande para que el bucle for

369
00:20:00,300 --> 00:20:02,540
iterará más veces.

370
00:20:02,540 --> 00:20:06,090
En este caso, me voy
para introducir un valor de 11.

371
00:20:06,090 --> 00:20:08,390
>> Ahora, de nuevo porque me puse
un punto de quiebre en la línea 15,

372
00:20:08,390 --> 00:20:10,490
se va a poner de relieve esa línea.

373
00:20:10,490 --> 00:20:12,980
Podemos ver que nuestro
número 11 es correcta

374
00:20:12,980 --> 00:20:15,560
representado en nuestras variables locales.

375
00:20:15,560 --> 00:20:22,460
Pasando por encima de eso, podemos ahora
observa lo que sucede a nuestro valor de i

376
00:20:22,460 --> 00:20:25,680
a medida que avancemos en el interior de este bucle.

377
00:20:25,680 --> 00:20:31,960
Se pone incrementa cada vez que
llegar a la cima de ese bucle.

378
00:20:31,960 --> 00:20:35,110
>> Ahora una de las cosas que podría
ser útil para hacer durante la ejecución

379
00:20:35,110 --> 00:20:40,490
de este programa es para mí realmente
cambiar el medio de la corriente de variables para ver

380
00:20:40,490 --> 00:20:42,450
lo que pasa a mi programa.

381
00:20:42,450 --> 00:20:46,540
En este caso, no puedo realmente
haga doble clic en el valor.

382
00:20:46,540 --> 00:20:48,040
Observe que se convierte en un campo de texto.

383
00:20:48,040 --> 00:20:50,280
>> Ahora puedo entrar en diferente
valorar por completo

384
00:20:50,280 --> 00:20:55,700
para ver cómo se comporta mi programa
cuando he cambiado esa variable.

385
00:20:55,700 --> 00:20:59,560
Ahora, en este caso, la variable
i ahora contiene el valor 10.

386
00:20:59,560 --> 00:21:02,810
Pero el programa sigue siendo
pausa en la ejecución.

387
00:21:02,810 --> 00:21:07,610
Cuando doy un paso más, veo que la
i valor, que entré en el 10,

388
00:21:07,610 --> 00:21:12,170
no es mayor que el valor de num,
que de inmediato hace que el bucle for

389
00:21:12,170 --> 00:21:14,240
para detener la ejecución.

390
00:21:14,240 --> 00:21:16,210
>> Ahora eso no es el único
razón por la que lo haría

391
00:21:16,210 --> 00:21:19,450
querer modificar la variable en su lugar.

392
00:21:19,450 --> 00:21:22,210
Usted puede ser que realmente quiere
para tratar de modificarlo para

393
00:21:22,210 --> 00:21:24,590
que puede continuar
ejecución de un bucle

394
00:21:24,590 --> 00:21:27,370
o para que usted puede modificar
algún valor antes de que se

395
00:21:27,370 --> 00:21:32,630
llega a un conjunto específico de la aritmética
que está a punto de realizar.

396
00:21:32,630 --> 00:21:36,210
>> Así que ahora que en realidad cambiamos el
valor de i que el programa se ejecuta,

397
00:21:36,210 --> 00:21:39,540
causó el bucle for para dejar de fumar
prematuramente porque, de repente, me

398
00:21:39,540 --> 00:21:42,770
pasó a ser mayor que el valor
de num, lo que significa que ese bucle for

399
00:21:42,770 --> 00:21:45,410
ya no es necesario para ser ejecutado.

400
00:21:45,410 --> 00:21:48,780
Además, pasó a ser el
caso de que cambiamos el valor de i

401
00:21:48,780 --> 00:21:53,270
cuando se puso de relieve la línea 17,
que era el punto en el tiempo

402
00:21:53,270 --> 00:21:56,280
para que la ejecución del bucle
fue en realidad se está evaluando.

403
00:21:56,280 --> 00:22:00,210
>> Si yo hubiera cambiado el valor de
i en una línea diferente, digo 19,

404
00:22:00,210 --> 00:22:03,360
habríamos visto diferente
comportamiento porque la línea 19 lo haría

405
00:22:03,360 --> 00:22:08,310
haber ejecutado antes del bucle
condición fue reevaluado.

406
00:22:08,310 --> 00:22:11,900
Ahora en este momento, estoy, de nuevo,
al final de este programa.

407
00:22:11,900 --> 00:22:15,707
Y puedo permitir que esto continúe con
permita que mi programa para dejar de fumar de forma natural.

408
00:22:15,707 --> 00:22:18,290
Pero hay un par de cosas
que son importantes para llevar

409
00:22:18,290 --> 00:22:19,960
de esta discusión particular.

410
00:22:19,960 --> 00:22:22,490
Es necesario evaluar
sus propias suposiciones

411
00:22:22,490 --> 00:22:24,710
acerca de cómo el código debe ser comportando.

412
00:22:24,710 --> 00:22:28,220
Cada vez que usted piensa que alguna pieza
de código que sabes pasa a trabajar,

413
00:22:28,220 --> 00:22:30,940
que podría ser una bandera roja para ir
atrás y evaluar, y asegúrese

414
00:22:30,940 --> 00:22:33,470
que asumido
cómo ese código está funcionando

415
00:22:33,470 --> 00:22:38,290
es realmente fiel a la forma en que es
expresado en el código fuente.

416
00:22:38,290 --> 00:22:41,300
>> Pero aún más a punto era,
cuando estamos usando el depurador,

417
00:22:41,300 --> 00:22:43,920
usted puede poner puntos de ruptura en
diferentes líneas de código,

418
00:22:43,920 --> 00:22:48,110
lo que provocará que el depurador
detener la ejecución en cada una de esas líneas

419
00:22:48,110 --> 00:22:52,210
para que pueda evaluar la
memoria o incluso cambiar en su lugar.

420
00:22:52,210 --> 00:22:55,630
Y de nuevo, recuerde que usted puede
crear múltiples puntos de interrupción para que

421
00:22:55,630 --> 00:23:00,390
También puede reanudar la ejecución, omita
sobre grandes porciones de código,

422
00:23:00,390 --> 00:23:04,790
y que va a hacer una pausa de forma automática
en el siguiente punto de ruptura.

423
00:23:04,790 --> 00:23:07,760
>> De hecho, hay más avanzado
características del depurador, también.

424
00:23:07,760 --> 00:23:10,170
Pero vamos a tener que hacer referencia que
a algunos videos posteriores

425
00:23:10,170 --> 00:23:14,090
con el fin de burlarse de verdad, aparte de cómo
utilizar esas funciones particulares.

426
00:23:14,090 --> 00:23:15,990
Por ahora, gracias
mucho para ver.

427
00:23:15,990 --> 00:23:18,080
Y buena suerte depuración.