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

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS :?] Hi,
Eu son [? Dan Armadaras?].

3
00:00:02,350 --> 00:00:04,410
Hoxe, nós estamos indo a
estar a ollar para a depuración.

4
00:00:04,410 --> 00:00:06,697
Non só estamos indo a
falar sobre algunhas técnicas,

5
00:00:06,697 --> 00:00:09,280
pero tamén imos ollar para
algunhas das características contidas

6
00:00:09,280 --> 00:00:14,170
dentro do IDE CS50 que permiten
vostede depurar facilmente un programa.

7
00:00:14,170 --> 00:00:16,272
>> Só un exemplo de
algo que pode dar mal

8
00:00:16,272 --> 00:00:18,730
e é realmente algo
que xa vimos antes.

9
00:00:18,730 --> 00:00:23,200
Neste caso, trátase dun programa C
que acepta un enteiro dende o usuario,

10
00:00:23,200 --> 00:00:27,580
divide por dous, e ofrece
a saída ao seu usuario.

11
00:00:27,580 --> 00:00:30,610
Agora, a partir do que vimos
anteriormente en conferencias,

12
00:00:30,610 --> 00:00:34,370
sabemos que isto vai realmente causar
tipos específicos de problemas de división

13
00:00:34,370 --> 00:00:35,860
cando temos números impares.

14
00:00:35,860 --> 00:00:40,330
>> En concreto, imos simplemente tirar
algo despois do punto decimal.

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

16
00:00:43,170 --> 00:00:47,430
E se nós executalo, podemos confirmar
nosas sospeitas, primeiro, compilando.

17
00:00:47,430 --> 00:00:50,460
E, a continuación, executando e
inserindo un número impar.

18
00:00:50,460 --> 00:00:51,720
>> Iso non é novidade.

19
00:00:51,720 --> 00:00:54,490
Pero este é realmente un
exemplo dun erro que

20
00:00:54,490 --> 00:00:58,810
pode existir dentro dun programa máis
que se fai máis difícil de rastrexar.

21
00:00:58,810 --> 00:01:02,640
A pesar de sabermos cal é o problema
é, o certo cerne da cuestión

22
00:01:02,640 --> 00:01:06,250
pode estar tentando identificar
especialmente onde a erro ocorre,

23
00:01:06,250 --> 00:01:09,750
identificar o que este problema
é, a continuación, fixándose o.

24
00:01:09,750 --> 00:01:14,400
Por iso, proporcionar isto como un exemplo
do que podería ser algo

25
00:01:14,400 --> 00:01:19,030
que xa sabemos, pero pode ser enterrado
dentro doutros elementos do código.

26
00:01:19,030 --> 00:01:23,090
>> Así, abrindo esta outra fonte
arquivo de código como un exemplo,

27
00:01:23,090 --> 00:01:27,165
este problema de división é agora
parte dun programa máis grande.

28
00:01:27,165 --> 00:01:29,040
Aínda pode ser un pouco
pouco artificial, e nós

29
00:01:29,040 --> 00:01:31,076
Pode ser capaz de facilmente
identificalo, especialmente

30
00:01:31,076 --> 00:01:32,450
xa que estamos só discutindo iso.

31
00:01:32,450 --> 00:01:38,250
Pero podemos descubrir que esta
problema pode existir nunha escala maior.

32
00:01:38,250 --> 00:01:45,450
>> Se eu compilar iso e agora
executalo, escriba un número impar,

33
00:01:45,450 --> 00:01:49,816
vemos que non conseguimos precisamente
a saída que podemos esperar.

34
00:01:49,816 --> 00:01:51,690
Neste caso particular,
poderiamos dicir que nós

35
00:01:51,690 --> 00:01:56,060
quere contar todos os números
de un a un número específico.

36
00:01:56,060 --> 00:01:58,130
E vemos que
ten unha variedade de cuestións

37
00:01:58,130 --> 00:02:03,880
aquí se está saída simplemente 0
e 1, cando nós fornecen unha entrada de 5.

38
00:02:03,880 --> 00:02:07,380
>> Entón, nós xa sabemos que
hai un problema aquí.

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

40
00:02:11,662 --> 00:02:13,620
Agora, unha das formas que
podemos tentar corrixir isto

41
00:02:13,620 --> 00:02:15,745
é algo que temos
xa aparecen para.

42
00:02:15,745 --> 00:02:18,880
Podemos só usalo nunha escala maior.

43
00:02:18,880 --> 00:02:21,680
>> Na liña 14, temos
esta función printf,

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

45
00:02:25,620 --> 00:02:28,880
E iso é algo que
debe aproveitar dentro do seu programa

46
00:02:28,880 --> 00:02:33,100
para tratar de descubrir o que é
pasando en varias liñas de código.

47
00:02:33,100 --> 00:02:36,350
Así, aínda que este non é o
resultado final que, en realidade,

48
00:02:36,350 --> 00:02:39,830
quere producir fóra do
Neste programa, aínda

49
00:02:39,830 --> 00:02:42,300
pode ter algunha depuración
declaracións onde nós

50
00:02:42,300 --> 00:02:46,970
pode tentar descubrir exactamente o que
está a suceder dentro do noso código.

51
00:02:46,970 --> 00:02:51,210
>> Polo tanto, neste caso, eu vou
printf co tag de depuración.

52
00:02:51,210 --> 00:02:53,540
Neste caso, trátase
só unha secuencia de depuración

53
00:02:53,540 --> 00:02:56,840
que eu estou poñendo-se a que se faga
moi claro na saída do meu código

54
00:02:56,840 --> 00:02:59,200
que é o que quero amosar.

55
00:02:59,200 --> 00:03:04,410
E aquí o número de saída
que temos calculado.

56
00:03:04,410 --> 00:03:06,800
>> Neste caso, eu podería
quero saber exactamente

57
00:03:06,800 --> 00:03:11,380
o que está a suceder antes e
tras algúns cálculos específicos.

58
00:03:11,380 --> 00:03:16,224
Entón eu podería usar un printf antes
e despois de que a liña de código.

59
00:03:16,224 --> 00:03:18,640
Neste caso, eu podería incluso
facelo un pouco máis clara

60
00:03:18,640 --> 00:03:21,960
dicindo depuración antes
e depuración despois de tanto

61
00:03:21,960 --> 00:03:26,540
que eu non confundir-me con
varias liñas que parecen idénticas.

62
00:03:26,540 --> 00:03:32,290
>> Agora, se nós recompilar este e executar
Lo, escriba un número como cinco de novo,

63
00:03:32,290 --> 00:03:35,090
vemos que temos
Agora saída antes e despois

64
00:03:35,090 --> 00:03:40,670
e cre que non fixemos unha clara
división ou ter claro do número

65
00:03:40,670 --> 00:03:43,680
que realmente queremos facer.

66
00:03:43,680 --> 00:03:48,660
Agora, neste caso, esta é
non é realmente unha saída clara.

67
00:03:48,660 --> 00:03:52,440
Non é realmente un resultado claro que
queremos fóra deste programa particular.

68
00:03:52,440 --> 00:03:54,427
>> E isto é, de novo, unha
pouco artificial.

69
00:03:54,427 --> 00:03:57,510
Pero, quizais, unha das cousas que
poderíamos facer a especificación dixo

70
00:03:57,510 --> 00:04:01,900
que queremos dividir isto por
2 e engadir 1-- Así, noutras palabras,

71
00:04:01,900 --> 00:04:04,550
queremos redondear up-- continuación
podemos saber que puidésemos

72
00:04:04,550 --> 00:04:08,060
facer esa cousa particular, neste caso.

73
00:04:08,060 --> 00:04:14,010
Agora aquí sabemos que seremos
capaz de engadir 1 ao noso número á metade.

74
00:04:14,010 --> 00:04:16,490
>> Imos recompilar este
e confirmar que esta

75
00:04:16,490 --> 00:04:18,860
está comportándose de maneira que queremos.

76
00:04:18,860 --> 00:04:21,980
Podemos ver que agora antes
tendo, temos o número 5.

77
00:04:21,980 --> 00:04:26,620
Despois de que ten o número 3,
que de acordo coa nosa especificación,

78
00:04:26,620 --> 00:04:29,292
é o que queriamos facer.

79
00:04:29,292 --> 00:04:31,000
Pero se miramos para o
saída aquí, podemos

80
00:04:31,000 --> 00:04:33,760
ver que poderiamos ter outro
Recheo completo, que é

81
00:04:33,760 --> 00:04:36,940
que estamos comezando a conta desde 0.

82
00:04:36,940 --> 00:04:39,390
>> Agora, de novo, iso é algo
que vimos no pasado

83
00:04:39,390 --> 00:04:42,500
e que poidamos resolve moi facilmente.

84
00:04:42,500 --> 00:04:44,790
Pero, neste caso, nós
tamén tiña o beneficio

85
00:04:44,790 --> 00:04:48,940
usar a instrución printf
directamente dentro do loop for

86
00:04:48,940 --> 00:04:52,930
para saber exactamente onde
que o erro estaba ocorrendo.

87
00:04:52,930 --> 00:04:55,150
Entón, son declaracións printf
moi útil para axudar

88
00:04:55,150 --> 00:04:57,940
a determinar onde,
precisamente no seu código fonte,

89
00:04:57,940 --> 00:05:00,620
un erro específico se produciron.

90
00:05:00,620 --> 00:05:03,650
>> E tamén é importante entender
que, como estamos escribindo código,

91
00:05:03,650 --> 00:05:06,052
poderiamos ter premisas
sobre o estado dun programa.

92
00:05:06,052 --> 00:05:08,510
Ou que teñamos premisas
sobre o que parte do programa

93
00:05:08,510 --> 00:05:13,020
é realmente correcto ou incorrecto cando
máis tarde, a medida que construímos sobre este programa

94
00:05:13,020 --> 00:05:15,950
e facelo parte dunha
complexo e programa maior

95
00:05:15,950 --> 00:05:19,700
que nos damos conta de que algún aspecto
de que é realmente buggy.

96
00:05:19,700 --> 00:05:22,680
>> Usando printf realmente pode axudar
diminuír e identificar

97
00:05:22,680 --> 00:05:26,430
As rexións dun programa que non pode
estar comportándose exactamente do xeito que nós

98
00:05:26,430 --> 00:05:29,500
esperar, en base ás nosas suposicións.

99
00:05:29,500 --> 00:05:31,460
Pero hai outras ferramentas
dispoñible, así como,

100
00:05:31,460 --> 00:05:34,860
que nos permiten tratar figura
fóra onde se produciron un erro

101
00:05:34,860 --> 00:05:39,930
e tamén, en concreto, o que as cousas
están a suceder dentro do programa.

102
00:05:39,930 --> 00:05:41,990
>> Entón, usando printf é moi
cando queremos útil

103
00:05:41,990 --> 00:05:45,900
para identificar áreas específicas de
un programa que ten algún erro.

104
00:05:45,900 --> 00:05:47,730
Pero tamén se fai
tedioso despois dun tempo.

105
00:05:47,730 --> 00:05:50,500
Neste caso, trátase dun
programa relativamente sinxelo

106
00:05:50,500 --> 00:05:52,750
con só unha ou dúas variables.

107
00:05:52,750 --> 00:05:57,260
E tórnase moi fácil para nós
imprimir o valor destas variables

108
00:05:57,260 --> 00:05:59,670
no contexto do programa máis grande.

109
00:05:59,670 --> 00:06:02,670
>> Pero podemos ter un diferente
programa que ten moitas variables.

110
00:06:02,670 --> 00:06:06,530
E iso non pode ser completamente
tan fácil de usar printf

111
00:06:06,530 --> 00:06:10,120
para tratar de avaliar o que está a suceder
para cada unha destas variables

112
00:06:10,120 --> 00:06:13,590
como o programa está en execución.

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

114
00:06:16,960 --> 00:06:20,320
Neste caso, a que iremos
uso é o depurador GNU, ou GDB,

115
00:06:20,320 --> 00:06:24,260
que nos permite inspeccionar o interior
funcionamento dun programa nun moito máis

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

117
00:06:25,700 --> 00:06:28,810
>> Podemos realmente executar
GDB da liña de comandos

118
00:06:28,810 --> 00:06:35,370
aquí simplemente escribindo GDB e
orde que desexe depurar.

119
00:06:35,370 --> 00:06:37,550
Neste caso, contan.

120
00:06:37,550 --> 00:06:41,650
Agora, neste caso, podemos ver que
nos leva a un poder que se GDB.

121
00:06:41,650 --> 00:06:44,020
E podemos, de feito,
executar comandos para GDB

122
00:06:44,020 --> 00:06:48,260
para efectivamente iniciar a execución do
programa, paralo en certos puntos,

123
00:06:48,260 --> 00:06:51,060
avaliar as variables e
inspeccionar as variables que

124
00:06:51,060 --> 00:06:54,152
existe no estado de programa
naquel momento en particular,

125
00:06:54,152 --> 00:06:55,110
e así por diante e así por diante.

126
00:06:55,110 --> 00:06:57,240
Ofrece unha gran cantidade de enerxía para nós.

127
00:06:57,240 --> 00:06:59,960
>> Pero iso só acontece
que o IDE tamén CS50

128
00:06:59,960 --> 00:07:05,870
ofrece unha interface gráfica ou un usuario
interface para que o GDB

129
00:07:05,870 --> 00:07:11,120
permítenos facelo sen necesidade de
a interface de liña de comandos que sexa

130
00:07:11,120 --> 00:07:13,560
ou en todo mesmo.

131
00:07:13,560 --> 00:07:16,930
O xeito que eu poida acceder a este
é usando o botón de depuración

132
00:07:16,930 --> 00:07:20,120
na parte superior do IDE CS50.

133
00:07:20,120 --> 00:07:24,280
Agora, no pasado, o que temos
visto é que usamos o comando

134
00:07:24,280 --> 00:07:27,660
liña para compilar e, a continuación, realizar un programa.

135
00:07:27,660 --> 00:07:29,790
>> O botón de depuración fai
ambos os pasos.

136
00:07:29,790 --> 00:07:34,380
Pero tamén vai traer o
guía depurador na extrema dereita

137
00:07:34,380 --> 00:07:38,280
que nos permite inspeccionar unha variedade
de propiedades do programa

138
00:07:38,280 --> 00:07:40,500
como está en execución.

139
00:07:40,500 --> 00:07:44,280
Se eu premer depuración, neste
caso, será

140
00:07:44,280 --> 00:07:48,230
unha nova guía na consola
ventá na parte inferior.

141
00:07:48,230 --> 00:07:51,160
>> E podes ver que esta guía ten
unha información na parte superior.

142
00:07:51,160 --> 00:07:52,670
E podemos, en gran parte ignorar isto.

143
00:07:52,670 --> 00:07:54,800
Pero unha das cousas
que queremos destacar

144
00:07:54,800 --> 00:07:57,170
é que exhiba
o mesmo que nós

145
00:07:57,170 --> 00:08:03,000
obtería se intentamos executar make en
o programa C na fiestra da terminal.

146
00:08:03,000 --> 00:08:06,230
>> Aquí podemos ver que funciona clang,
e que ten unha variedade de bandeiras,

147
00:08:06,230 --> 00:08:12,660
e está compilando noso arquivo count.c,
que foi o guía seleccionada no momento

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

149
00:08:15,100 --> 00:08:18,010
Entón iso é moi útil porque
agora usando este botón de depuración,

150
00:08:18,010 --> 00:08:23,280
podemos simultaneamente compilar e, a continuación,
realizar o programa que realmente

151
00:08:23,280 --> 00:08:24,460
quere facer.

152
00:08:24,460 --> 00:08:27,880
>> Unha das bandeiras que é
importante, neste caso,

153
00:08:27,880 --> 00:08:30,190
fomos realmente usando
por máis tempo

154
00:08:30,190 --> 00:08:32,450
pero tamén só fixen algunha man
acenando [inaudível], que

155
00:08:32,450 --> 00:08:33,820
é este aquí.

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

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

158
00:08:38,570 --> 00:08:41,250
Neste caso, o que somos
dicindo clang, o noso compilador,

159
00:08:41,250 --> 00:08:43,820
é que queremos para compilar noso programa.

160
00:08:43,820 --> 00:08:46,810
Pero tamén proporcionar o que son
chamado de información símbolo

161
00:08:46,810 --> 00:08:50,940
para que o compilador realmente ten acceso
para unha gran parte da información subxacente

162
00:08:50,940 --> 00:08:52,610
contido dentro do programa.

163
00:08:52,610 --> 00:08:55,260
>> En concreto, o número
das funcións que eu teño,

164
00:08:55,260 --> 00:08:58,000
os nomes destas funcións,
as variables, tipo

165
00:08:58,000 --> 00:09:01,730
que as variables son, e unha variedade
de outras cousas que axudan o depurador

166
00:09:01,730 --> 00:09:04,350
realizar o seu funcionamento.

167
00:09:04,350 --> 00:09:06,600
Agora hai unha cousa
que é importante mencionar

168
00:09:06,600 --> 00:09:10,280
cando estamos discutindo running
un programa deste xeito.

169
00:09:10,280 --> 00:09:13,660
>> Teña en conta que ten, de feito,
trouxo á tona unha nova guía no noso consola

170
00:09:13,660 --> 00:09:14,780
ao longo do fondo.

171
00:09:14,780 --> 00:09:18,600
Xa non teñen que interactuar
directamente coa ventá do terminal.

172
00:09:18,600 --> 00:09:21,420
Pero este novo guía é
de feito, unha fiestra de terminal.

173
00:09:21,420 --> 00:09:26,710
E só é específico para o funcionamento
programa que creamos.

174
00:09:26,710 --> 00:09:29,270
>> Nótese que no fondo, en
combinación con algunha saída

175
00:09:29,270 --> 00:09:33,500
por clang o compilador e GDB,
que podemos ignorar en gran parte,

176
00:09:33,500 --> 00:09:37,570
que realmente mostra a saída de
noso programa na parte inferior.

177
00:09:37,570 --> 00:09:41,240
Agora é importante entender
que este diálogo realmente

178
00:09:41,240 --> 00:09:43,360
ha amosar-lle o
saída do seu programa

179
00:09:43,360 --> 00:09:47,190
pero tamén pode aceptar a entrada
para ese programa, así.

180
00:09:47,190 --> 00:09:49,260
>> Entón nota que di
Introduza un número,

181
00:09:49,260 --> 00:09:53,050
que é o mesmo saída que
tiña na fiestra da terminal antes.

182
00:09:53,050 --> 00:09:55,510
Pero agora aparece nesta nova guía.

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

184
00:09:56,550 --> 00:10:00,900
E vai realmente
función como esperamos

185
00:10:00,900 --> 00:10:05,890
mostrando noso depuración, de saída,
a saída que se pode buggy,

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

187
00:10:07,010 --> 00:10:10,460
E ben no fondo, el
realmente ten algunha saída adicional

188
00:10:10,460 --> 00:10:14,550
do PIB só dicindo que
este programa se completa.

189
00:10:14,550 --> 00:10:16,655
>> Agora, como viu neste
especial de execución por medio,

190
00:10:16,655 --> 00:10:19,370
non foi particularmente
útil porque aínda

191
00:10:19,370 --> 00:10:23,740
aínda tivemos o menú depurador vir
se, este aínda era un programa en execución.

192
00:10:23,740 --> 00:10:26,790
En ningún momento realmente
deter a execución para nós

193
00:10:26,790 --> 00:10:30,767
para poder inspeccionar todos
as variables contidos.

194
00:10:30,767 --> 00:10:32,850
Hai algo máis
que temos que facer, a fin

195
00:10:32,850 --> 00:10:36,910
para GDB recoñecer que queremos
para deter a execución do programa

196
00:10:36,910 --> 00:10:42,820
e non só permitir que continúe
normalmente como sería en calquera outro caso.

197
00:10:42,820 --> 00:10:45,530
>> Co fin de deter a execución,
nalgunha liña específica,

198
00:10:45,530 --> 00:10:47,830
necesitamos crear o que é
chamado un punto de ruptura.

199
00:10:47,830 --> 00:10:52,670
E un punto de quebra é moi facilmente creado
neste CS50 IDE, tendo o seu rato

200
00:10:52,670 --> 00:10:57,090
e premendo directamente á esquerda
dun número de liña específico.

201
00:10:57,090 --> 00:10:59,920
Xa que eu fago isto, un punto vermello
aparece, o que indica

202
00:10:59,920 --> 00:11:02,300
que esta liña é agora un punto de ruptura.

203
00:11:02,300 --> 00:11:07,540
>> E a próxima vez que eu corro GDB, esta
ha parar a execución nese punto de quebra

204
00:11:07,540 --> 00:11:10,280
cando alcanza esta liña de código.

205
00:11:10,280 --> 00:11:12,230
Agora, este é un importante
cousa que entender

206
00:11:12,230 --> 00:11:16,140
que non é necesariamente o
caso en que cada liña de código

207
00:11:16,140 --> 00:11:17,880
en realidade, é accesible.

208
00:11:17,880 --> 00:11:23,780
Se eu fose para crear unha función
ata aquí, para F-- baleiro example--

209
00:11:23,780 --> 00:11:31,230
e só facer unha liña de impresión aqui-- Ola
mundo-- se eu nunca chamar esta función,

210
00:11:31,230 --> 00:11:34,770
que será o caso de que,
se eu definir un break point aquí,

211
00:11:34,770 --> 00:11:36,220
a función nunca será chamado.

212
00:11:36,220 --> 00:11:38,310
E, polo tanto, este
especial break point

213
00:11:38,310 --> 00:11:43,040
nunca realmente pausa
a execución do programa.

214
00:11:43,040 --> 00:11:48,020
>> Entón, digamos que eu crear correctamente
un punto de ruptura nalgún liña de código

215
00:11:48,020 --> 00:11:50,340
que vai realmente ser executado.

216
00:11:50,340 --> 00:11:53,470
Agora, neste caso, esta é a
primeira liña na función principal.

217
00:11:53,470 --> 00:11:56,630
Por iso, será certamente o caso
que, así que eu comezar a execución,

218
00:11:56,630 --> 00:11:58,580
a primeira liña será alcanzar.

219
00:11:58,580 --> 00:12:00,230
GDB vai parar a execución.

220
00:12:00,230 --> 00:12:04,100
E entón, eu serei capaz de
interactuar co depurador.

221
00:12:04,100 --> 00:12:08,480
>> Podes establecer varias liñas como
puntos de interrupción, se desexa.

222
00:12:08,480 --> 00:12:11,365
Tamén podemos crear unha liña superior
aquí neste segmento de código

223
00:12:11,365 --> 00:12:12,490
que nunca será alcanzar.

224
00:12:12,490 --> 00:12:14,744
E nós tamén pode definir unha máis abaixo.

225
00:12:14,744 --> 00:12:16,660
A razón que nós
quero facelo nós imos

226
00:12:16,660 --> 00:12:19,119
entrar nun pouco máis
detalles en só un momento.

227
00:12:19,119 --> 00:12:21,660
Entón, por agora, déixeme só desactivar
estes puntos de quebra adicionais

228
00:12:21,660 --> 00:12:24,940
para que poidamos ver que pasa
cando eu teño unha única pausa

229
00:12:24,940 --> 00:12:27,650
punto no meu programa.

230
00:12:27,650 --> 00:12:29,410
Eu fixen algúns
cambios a este programa.

231
00:12:29,410 --> 00:12:30,750
Entón, eu teño salvalo.

232
00:12:30,750 --> 00:12:34,490
Vou prema depuración para que eu poida
comezar a compilación e, a continuación,

233
00:12:34,490 --> 00:12:36,880
execución do depurador.

234
00:12:36,880 --> 00:12:40,632
>> Veremos que, despois de momentos, os
liña que foi seleccionada como a quebra

235
00:12:40,632 --> 00:12:43,360
punto é destacado en amarelo.

236
00:12:43,360 --> 00:12:47,440
Tamén podemos destacar que no
parte superior dereita do panel de depuración

237
00:12:47,440 --> 00:12:50,940
que a icona de pausa converteuse
nun pequeno icono de xogo.

238
00:12:50,940 --> 00:12:54,710
Isto significa que temos de pausa
execución, neste caso en particular.

239
00:12:54,710 --> 00:12:57,840
E usar o botón Reproducir se
permitir-nos seguir a execución

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

241
00:13:00,000 --> 00:13:03,240
>> Teña en conta que hai un par de outro
botóns dispoñibles neste panel de depuración,

242
00:13:03,240 --> 00:13:04,220
ben.

243
00:13:04,220 --> 00:13:09,470
Pasar por riba, o que me permite
executar que unha liña de código

244
00:13:09,470 --> 00:13:14,030
e pasar por riba desa liña para o
seguinte, o que, neste caso,

245
00:13:14,030 --> 00:13:17,060
significaría que o printf
instrución é executada.

246
00:13:17,060 --> 00:13:22,310
E, a continuación, facer unha pausa
execución na liña 13, así.

247
00:13:22,310 --> 00:13:25,090
>> E hai tamén un paso
en función, que

248
00:13:25,090 --> 00:13:28,950
é útil se eu creei outro
funcións noutras partes do código fonte.

249
00:13:28,950 --> 00:13:31,420
E quero entrar
estas funcións, no canto de

250
00:13:31,420 --> 00:13:33,050
realizar esta función no seu conxunto.

251
00:13:33,050 --> 00:13:37,279
Pero imos ollar máis para o paso
en función só en un momento.

252
00:13:37,279 --> 00:13:40,320
Agora notar algunhas outras cousas que
realmente existen dentro do taboleiro de depuración.

253
00:13:40,320 --> 00:13:44,110
>> Temos este panel de chamada
chamar pila, que nos mostra

254
00:13:44,110 --> 00:13:45,300
exactamente onde estamos.

255
00:13:45,300 --> 00:13:48,550
Neste caso, estamos dentro
da función principal.

256
00:13:48,550 --> 00:13:50,880
Noso script chámase count.c.

257
00:13:50,880 --> 00:13:53,820
E nós ocorrer de ser en
liña 13, columna un, que

258
00:13:53,820 --> 00:13:58,950
é precisamente o que a rexión en destaque
do código fonte indica, como ben.

259
00:13:58,950 --> 00:14:02,435
>> Agora conta que isto tamén mostra
baixo a sección variable local

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

261
00:14:06,710 --> 00:14:08,930
É importante ter en conta
que todas as variables

262
00:14:08,930 --> 00:14:12,580
aparecerá nesta variable local
sección dentro dunha función,

263
00:14:12,580 --> 00:14:14,380
mesmo antes de ser definidas.

264
00:14:14,380 --> 00:14:19,160
Podemos ver aquí que temos unha variable
chamado nun, ten un valor por defecto de 0,

265
00:14:19,160 --> 00:14:21,280
e é de tipo int.

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

267
00:14:24,110 --> 00:14:26,685
non somos necesariamente
garantir a ver un valor de 0.

268
00:14:26,685 --> 00:14:29,200
E dependendo doutras execucións
que executou

269
00:14:29,200 --> 00:14:32,020
eo estado da súa memoria cando
realmente executar este programa,

270
00:14:32,020 --> 00:14:34,605
pode considerar que
Non vexo valores de 0

271
00:14:34,605 --> 00:14:36,550
e, no seu lugar, algúns outros números tolos.

272
00:14:36,550 --> 00:14:38,390
>> Pero non se preocupe con iso.

273
00:14:38,390 --> 00:14:44,610
Non vai ser relevante ata
realmente arrincar o valor.

274
00:14:44,610 --> 00:14:49,630
Agora, neste caso, podemos ver que
Teño realizado algúns saídas.

275
00:14:49,630 --> 00:14:52,131
E eu estou agora, parou a execución.

276
00:14:52,131 --> 00:14:53,880
Pero neste caso, o que
Realmente quero facer

277
00:14:53,880 --> 00:14:58,060
é para o paso agora sobre esta liña
de código para que eu poida realmente

278
00:14:58,060 --> 00:15:04,390
consultar o usuario para que int que
queremos usar no noso programa.

279
00:15:04,390 --> 00:15:07,060
>> Agora, neste caso, cando
Eu bati pasar por riba, aviso

280
00:15:07,060 --> 00:15:11,940
que a pausa ou mellor, o Resume
botón cambiou a este botón de pausa

281
00:15:11,940 --> 00:15:14,022
porque este código é realmente execución.

282
00:15:14,022 --> 00:15:15,730
Que está a pasar
Actualmente é que é

283
00:15:15,730 --> 00:15:21,630
esperando por nós para entrada de unha información
como vemos polo noso texto de saída

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

285
00:15:23,600 --> 00:15:25,787
>> Entón, agora, este é
Non, en realidade, fixo unha pausa,

286
00:15:25,787 --> 00:15:28,620
aínda que, de certa forma, parece
ser, porque nada está a suceder.

287
00:15:28,620 --> 00:15:32,360
Pero iso só acontece que,
meu caso específico na liña 13,

288
00:15:32,360 --> 00:15:34,210
Estou agardando entrada do usuario.

289
00:15:34,210 --> 00:15:39,130
E así GDB non é capaz de inspeccionar
un programa como está en execución.

290
00:15:39,130 --> 00:15:43,370
>> Agora, a próxima vez que eu entrar nalgúns
input-- entón eu vou entrar nese número 5,

291
00:15:43,370 --> 00:15:46,140
como vimos no
past-- bater Return, e nós

292
00:15:46,140 --> 00:15:51,430
Lembre que de inmediato, pausas GDB
e, de novo, destaca a liña seguinte.

293
00:15:51,430 --> 00:15:55,320
Pero teña en conta que agora, como un
resultado da nosa introducir un valor,

294
00:15:55,320 --> 00:15:58,930
nós actualizamos ese valor dentro
das nosas variables locais, que

295
00:15:58,930 --> 00:16:05,560
Isto é moi útil saber con precisión
o que este número estaba na memoria.

296
00:16:05,560 --> 00:16:10,650
>> Agora podo permitir que este programa continúe
xogar ata o final da súa execución

297
00:16:10,650 --> 00:16:12,570
por bater Resume.

298
00:16:12,570 --> 00:16:16,410
Podemos ver que moi rapidamente
fai o remate programa de execución

299
00:16:16,410 --> 00:16:19,790
coa mesma saída que
tiña antes, o depurador pecha,

300
00:16:19,790 --> 00:16:23,170
e agora este programa
deixou completamente.

301
00:16:23,170 --> 00:16:25,320
>> I mostran que só pola
efectos de ver que

302
00:16:25,320 --> 00:16:27,280
acontece cando nós realmente bater Resume.

303
00:16:27,280 --> 00:16:30,640
Pero nós realmente están indo
quero volver a este programa

304
00:16:30,640 --> 00:16:33,820
para que poidamos probar depurar
precisamente o que está pasando.

305
00:16:33,820 --> 00:16:37,980
Agora que está a usar o depurador, podo
Non precisa destas declaracións de depuración printf.

306
00:16:37,980 --> 00:16:43,860
>> Así eu podería eliminar-los como eu vou facer
Agora, só para volver para o noso código máis sinxelo

307
00:16:43,860 --> 00:16:45,950
que tivemos un momento atrás.

308
00:16:45,950 --> 00:16:48,790
Agora, cando eu gardar o
programar e executalo,

309
00:16:48,790 --> 00:16:53,700
ha, unha vez máis, ir aquel inicial
punto que eu tiña na liña 11 romper.

310
00:16:53,700 --> 00:16:57,700
E eu vou ser capaz de inspeccionar
meus variables como quero facer.

311
00:16:57,700 --> 00:17:00,695
>> Acontece que este
parte non é moi interesante,

312
00:17:00,695 --> 00:17:04,364
E sei que vou
imprimir esta declaración.

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

314
00:17:05,280 --> 00:17:08,099
E entón, eu sei que eu vou
pedir ao usuario para ese enteiro.

315
00:17:08,099 --> 00:17:13,329
Entón, talvez, realmente quero cambiar a miña
punto de romper un pouco máis abaixo.

316
00:17:13,329 --> 00:17:16,710
>> Pode eliminar puntos de interrupción
premendo de novo directamente

317
00:17:16,710 --> 00:17:18,460
á esquerda de que o número de liña.

318
00:17:18,460 --> 00:17:22,200
Ese punto vermello desaparecerá, indicando
que ese punto de quebra é ir agora.

319
00:17:22,200 --> 00:17:24,780
Agora, neste caso,
execución foi pausada.

320
00:17:24,780 --> 00:17:27,770
E por iso non é realmente indo
retomar nese caso particular.

321
00:17:27,770 --> 00:17:30,210
Pero podo definir unha pausa
apuntar un pouco máis tarde.

322
00:17:30,210 --> 00:17:33,880
>> E cando eu agora retomar a miña
código, será retomada e dizer-

323
00:17:33,880 --> 00:17:36,190
a punto de que o punto de quebra.

324
00:17:36,190 --> 00:17:37,374
Unha vez máis, eu bati Resume.

325
00:17:37,374 --> 00:17:39,040
Non parece que nada está a suceder.

326
00:17:39,040 --> 00:17:41,450
Pero iso é porque a miña
código está agardando entrada.

327
00:17:41,450 --> 00:17:47,900
Vou introducir un número 5, prema Intro, e
Agora, o seguinte punto de interrupción será acadar.

328
00:17:47,900 --> 00:17:50,570
>> Agora, neste caso, este
é a liña de código

329
00:17:50,570 --> 00:17:53,820
que, antes, sabiamos
pasou a ser buggy.

330
00:17:53,820 --> 00:17:57,590
Entón, imos avaliar o que pasa
neste momento particular no tempo.

331
00:17:57,590 --> 00:18:02,620
Cando unha liña é resaltada, este
A liña non foi executado.

332
00:18:02,620 --> 00:18:06,490
Polo tanto, neste caso, podemos ver
que eu teño un número, que

333
00:18:06,490 --> 00:18:11,610
Eu teño un número enteiro chamado
Nun que ten un valor 5.

334
00:18:11,610 --> 00:18:15,090
E eu vou estar realizando
un pouco de matemáticas en que número.

335
00:18:15,090 --> 00:18:20,130
>> Se eu pasar por riba diso, podemos
entender que o valor para o núm

336
00:18:20,130 --> 00:18:23,780
cambiou de acordo co
aritmética que temos realmente feito.

337
00:18:23,780 --> 00:18:26,810
E agora que estamos
dentro deste loop

338
00:18:26,810 --> 00:18:29,090
ou agora que o loop for
en si está en destaque,

339
00:18:29,090 --> 00:18:32,450
vemos que temos un novo
variable chamada i que

340
00:18:32,450 --> 00:18:35,370
será utilizado na medida en que a lazo.

341
00:18:35,370 --> 00:18:38,230
>> Agora lembre se antes de que eu
mencionou que ás veces está

342
00:18:38,230 --> 00:18:43,470
vai ver algún tipo de tolo
números por defecto antes de ese número

343
00:18:43,470 --> 00:18:45,530
ou que é variable
de feito iniciado.

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

345
00:18:49,040 --> 00:18:51,345
chamado I, que non posúe
Aínda non foi inicializado

346
00:18:51,345 --> 00:18:53,560
no momento de destacar.

347
00:18:53,560 --> 00:18:57,070
Pero podemos ver que ten un número
que non sería realmente esperar.

348
00:18:57,070 --> 00:18:57,620
>> Está ben.

349
00:18:57,620 --> 00:18:59,661
Non hai problema con iso
porque non temos, en realidade,

350
00:18:59,661 --> 00:19:04,970
iniciar ese número ata que eu
pasar por riba desta liña eo valor

351
00:19:04,970 --> 00:19:08,560
i foi inicializar co valor 1.

352
00:19:08,560 --> 00:19:11,400
Entón, a ver que iso é, en realidade,
o caso, imos pasar por riba.

353
00:19:11,400 --> 00:19:14,420
Podemos ver agora que ese
A liña foi executada.

354
00:19:14,420 --> 00:19:17,000
E agora estamos destacando
esta liña printf.

355
00:19:17,000 --> 00:19:22,230
>> E agora vemos como os nosos valores
i 3 e cambiaron ao longo do tempo.

356
00:19:22,230 --> 00:19:26,450
Isto é moi útil para facer, de feito,
é para pasar por riba de liñas repetidamente.

357
00:19:26,450 --> 00:19:30,480
E pode atopar o que realmente
acontece dentro do seu loop for

358
00:19:30,480 --> 00:19:33,660
eo que acontece coa
variables dentro dese loop

359
00:19:33,660 --> 00:19:39,200
como que a execución do programa
ocorre un paso á vez.

360
00:19:39,200 --> 00:19:41,110
>> Agora, neste momento, eu
pasou por riba só o suficiente

361
00:19:41,110 --> 00:19:44,210
que agora estou a finais do meu programa.

362
00:19:44,210 --> 00:19:46,980
Se eu pasar por riba diso, que vai
realmente cesar execución

363
00:19:46,980 --> 00:19:48,860
como vimos no pasado.

364
00:19:48,860 --> 00:19:52,110
Déixeme reiniciar este, unha vez máis, de xeito
que eu poida apuntar algo máis para fóra,

365
00:19:52,110 --> 00:19:53,320
ben.

366
00:19:53,320 --> 00:19:55,350
>> Neste caso, é
agora me preguntar, de novo,

367
00:19:55,350 --> 00:19:57,100
para un número, o cal
Eu vou, unha vez máis, entrar.

368
00:19:57,100 --> 00:20:00,300
Pero esta vez, eu vou entrar en
un número maior para que o loop for

369
00:20:00,300 --> 00:20:02,540
ha interactuar máis veces.

370
00:20:02,540 --> 00:20:06,090
Neste caso, eu vou
para introducir un valor de 11.

371
00:20:06,090 --> 00:20:08,390
>> Agora, de novo, porque eu tiña definido
un punto de interrupción na liña 15,

372
00:20:08,390 --> 00:20:10,490
vai destacar esa liña.

373
00:20:10,490 --> 00:20:12,980
Podemos ver que o noso
número 11 é correctamente

374
00:20:12,980 --> 00:20:15,560
representados nos locais variables.

375
00:20:15,560 --> 00:20:22,460
Pasando por riba diso, podemos agora
mira o que acontece ao seu valor de i

376
00:20:22,460 --> 00:20:25,680
a medida que proseguimos dentro deste loop.

377
00:20:25,680 --> 00:20:31,960
É incrementado cada vez que
chegar ao cumio do que para loop.

378
00:20:31,960 --> 00:20:35,110
>> Agora, unha das cousas que poden
ser útil para facer durante a execución

379
00:20:35,110 --> 00:20:40,490
deste programa é para min, en realidade,
cambiar o variables midstream para ver

380
00:20:40,490 --> 00:20:42,450
o que pasa co meu programa.

381
00:20:42,450 --> 00:20:46,540
Neste caso, podo realmente
prema dúas veces o valor.

382
00:20:46,540 --> 00:20:48,040
Teña en conta que pasa a ser un campo de texto.

383
00:20:48,040 --> 00:20:50,280
>> Agora podo entrar diferente
Valorados completamente

384
00:20:50,280 --> 00:20:55,700
para ver como o meu programa compórtase
cando eu mudei esta variable.

385
00:20:55,700 --> 00:20:59,560
Agora, neste caso, a variable
i agora contén o valor 10.

386
00:20:59,560 --> 00:21:02,810
Pero o programa aínda é
fixo unha pausa na execución.

387
00:21:02,810 --> 00:21:07,610
Cando pasar por riba, vexo que a
valor i, onde entrei como 10,

388
00:21:07,610 --> 00:21:12,170
non é maior que o valor de un,
o que inmediatamente fai que o loop for

389
00:21:12,170 --> 00:21:14,240
para deter a execución.

390
00:21:14,240 --> 00:21:16,210
>> Agora que non é o único
polo que faría

391
00:21:16,210 --> 00:21:19,450
quere modificar a variable no lugar.

392
00:21:19,450 --> 00:21:22,210
Pode realmente queren
para tratar de modificalo para

393
00:21:22,210 --> 00:21:24,590
que poida continuar
execución dun ciclo

394
00:21:24,590 --> 00:21:27,370
ou para que poida modificar
algún valor antes

395
00:21:27,370 --> 00:21:32,630
atinxe algún conxunto específico de aritmética
que está a piques de realizar.

396
00:21:32,630 --> 00:21:36,210
>> Polo tanto, agora que realmente cambiar a
valor de i que o programa estaba en execución,

397
00:21:36,210 --> 00:21:39,540
que causou o loop for para saír
prematuramente, porque, de súpeto, eu

398
00:21:39,540 --> 00:21:42,770
Pasou a ser maior que o valor
de nun, o que significa que este bucle

399
00:21:42,770 --> 00:21:45,410
non se necesita para ser executado.

400
00:21:45,410 --> 00:21:48,780
Ademais, el pasou a ser o
caso que nós cambiamos o valor de i

401
00:21:48,780 --> 00:21:53,270
cando a liña 17 foi destaque,
que foi o punto no tempo

402
00:21:53,270 --> 00:21:56,280
para que a execución do bucle
foi, de feito, está a ser avaliado.

403
00:21:56,280 --> 00:22:00,210
>> Se eu tivese cambiado o valor da
i nunha liña distinta, digamos 19,

404
00:22:00,210 --> 00:22:03,360
teriamos visto diferente
comportamento porque liña 19 sería

405
00:22:03,360 --> 00:22:08,310
executar antes do loop
condición foi reavaliada.

406
00:22:08,310 --> 00:22:11,900
Agora, neste momento, eu estou de novo,
a finais deste programa.

407
00:22:11,900 --> 00:22:15,707
E podo permitir que iso siga
facer que o meu programa para saír suposto.

408
00:22:15,707 --> 00:22:18,290
Pero hai un par de cousas
que son importantes para sacar

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

410
00:22:19,960 --> 00:22:22,490
Debe avaliar
súas propias suposicións

411
00:22:22,490 --> 00:22:24,710
sobre como o código debe estar comportándose.

412
00:22:24,710 --> 00:22:28,220
Cada vez que pensar que algunha peza
de código que sabe pasa para traballar,

413
00:22:28,220 --> 00:22:30,940
que pode ser unha bandeira vermella para ir
para atrás e avaliar, e ter a certeza

414
00:22:30,940 --> 00:22:33,470
que a súa asunción de
como que o código está funcionando

415
00:22:33,470 --> 00:22:38,290
é realmente verdade de como é
expresa no seu código fonte.

416
00:22:38,290 --> 00:22:41,300
>> Pero aínda máis a cuestión era,
cando estamos usando o depurador,

417
00:22:41,300 --> 00:22:43,920
pode pór puntos de interrupción en
diferentes liñas de código,

418
00:22:43,920 --> 00:22:48,110
o que fará que o depurador
deter a execución en cada unha destas liñas

419
00:22:48,110 --> 00:22:52,210
para que poida avaliar a
memoria ou incluso cambia-lo no lugar.

420
00:22:52,210 --> 00:22:55,630
E, de novo, lembre que pode
crear varios puntos de interrupción para que

421
00:22:55,630 --> 00:23:00,390
Tamén pode retomar a execución, pule
ao longo de grandes porcións de código,

422
00:23:00,390 --> 00:23:04,790
e que vai deixar automaticamente
o próximo punto de quebra.

423
00:23:04,790 --> 00:23:07,760
>> Hai realmente máis avanzado
recursos do depurador, así.

424
00:23:07,760 --> 00:23:10,170
Pero nós imos ter que encamiñar-lo
para algúns vídeos seguintes

425
00:23:10,170 --> 00:23:14,090
a fin de que realmente provocar unha separación como
para usar estas funcións específicas.

426
00:23:14,090 --> 00:23:15,990
Por agora, grazas
moito para ver.

427
00:23:15,990 --> 00:23:18,080
E boa sorte depuración.