1
00:00:00,000 --> 00:00:05,640

2
00:00:05,640 --> 00:00:06,830
>> DOUG LLOYD: Tudo bem GDB.

3
00:00:06,830 --> 00:00:08,480
O que é isso exatamente?

4
00:00:08,480 --> 00:00:11,310
Então GDB, que significa
para o GNU Debugger,

5
00:00:11,310 --> 00:00:15,040
é uma ferramenta realmente incrível que podemos
usar para nos ajudar a depurar os nossos programas,

6
00:00:15,040 --> 00:00:18,210
ou descobrir onde as coisas são
acontecendo de errado em nossos programas.

7
00:00:18,210 --> 00:00:22,590
GDB é incrivelmente poderoso, mas
a saída e interacção com ele

8
00:00:22,590 --> 00:00:23,830
pode ser um pouco enigmática.

9
00:00:23,830 --> 00:00:28,210
Geralmente é uma ferramenta de linha de comando, e
ele pode jogar um monte de mensagens para você.

10
00:00:28,210 --> 00:00:31,144
E pode tipo de difícil
analisar exatamente o que está acontecendo.

11
00:00:31,144 --> 00:00:33,560
Passos Felizmente, temos tido
para corrigir esse problema para você

12
00:00:33,560 --> 00:00:36,281
como você trabalha através CS50.

13
00:00:36,281 --> 00:00:39,030
Se você não estiver usando a gráfica
depurador, que o meu colega Dan

14
00:00:39,030 --> 00:00:41,570
Armandarse tem falado bastante
um pouco sobre em um vídeo que

15
00:00:41,570 --> 00:00:44,740
deve ser por aqui
agora, você pode precisar

16
00:00:44,740 --> 00:00:48,270
para usá-los linha de comando
ferramentas para trabalhar com o GDB.

17
00:00:48,270 --> 00:00:51,250
Se você estiver trabalhando no CS50
IDE, você não precisa fazer isso.

18
00:00:51,250 --> 00:00:53,550
Mas se você não é
trabalhando no CS50 IDE,

19
00:00:53,550 --> 00:00:55,750
talvez usando uma versão
CS50 de Appliance,

20
00:00:55,750 --> 00:00:58,860
ou operar outro Linux
sistema com GDB instalado nele,

21
00:00:58,860 --> 00:01:00,980
você pode precisar usar
essas ferramentas de linha de comando.

22
00:01:00,980 --> 00:01:02,860
>> E uma vez que você pode
tem que fazer isso, é

23
00:01:02,860 --> 00:01:06,280
útil apenas para entender como
GDB trabalha na linha de comando.

24
00:01:06,280 --> 00:01:09,650
Mas, novamente, se você estiver
usando a IDE CS50, você

25
00:01:09,650 --> 00:01:15,400
pode usar o depurador gráfico
que está incorporado no IDE.

26
00:01:15,400 --> 00:01:18,750
Então, para começar as coisas com
GDB, para iniciar a depuração

27
00:01:18,750 --> 00:01:21,220
processo de um determinado
programa, tudo que você precisa fazer

28
00:01:21,220 --> 00:01:23,810
é tipo GDB seguido
pelo nome do programa.

29
00:01:23,810 --> 00:01:28,620
Assim, por exemplo, se o seu programa é
Olá, você deverá digitar GDB Olá.

30
00:01:28,620 --> 00:01:31,210
>> Quando você faz isso, você está indo
para puxar para cima o ambiente GDB.

31
00:01:31,210 --> 00:01:33,800
O prompt vai mudar, e
em vez de ser o que é normalmente

32
00:01:33,800 --> 00:01:35,841
é quando você digita coisas
nas ls linha-- comando,

33
00:01:35,841 --> 00:01:38,115
cd-- todo o seu típico
Os comandos do Linux, seu prompt

34
00:01:38,115 --> 00:01:42,200
mudará para, provavelmente, algo
como parênteses GDB parênteses.

35
00:01:42,200 --> 00:01:46,630
Esse é o seu novo prompt GDB, porque
você está dentro do ambiente GDB.

36
00:01:46,630 --> 00:01:49,830
Uma vez dentro desse ambiente,
há dois grandes comandos

37
00:01:49,830 --> 00:01:52,290
que você provavelmente vai usar
na seguinte ordem.

38
00:01:52,290 --> 00:01:55,200
>> O primeiro é b, que
é curto para o intervalo.

39
00:01:55,200 --> 00:01:58,690
E depois que você digite b, você normalmente
digite o nome de uma função,

40
00:01:58,690 --> 00:02:01,040
ou se acontecer de você saber
em torno do que o número da linha

41
00:02:01,040 --> 00:02:04,100
o programa está começando
comportar-se um pouco estranho,

42
00:02:04,100 --> 00:02:06,370
você pode digitar uma linha
Número de lá também.

43
00:02:06,370 --> 00:02:09,660
O que b, ou fim, faz
é que permite que seu programa

44
00:02:09,660 --> 00:02:13,270
para executar até um certo ponto,
nomeadamente, o nome da função

45
00:02:13,270 --> 00:02:15,880
que você especificar ou a linha
número que você especificar.

46
00:02:15,880 --> 00:02:18,590
>> E nesse ponto,
vai congelar a execução.

47
00:02:18,590 --> 00:02:21,670
Isso é uma coisa muito boa, porque
uma vez que a execução tenha sido congelada,

48
00:02:21,670 --> 00:02:25,214
você pode começar a muito lentamente
passo através de seu programa.

49
00:02:25,214 --> 00:02:28,130
Normalmente, se você estive correndo
seus programas, eles são muito curta.

50
00:02:28,130 --> 00:02:31,250
Normalmente, você digita o que quer barra dot
o nome do seu programa, pressione a tecla Enter,

51
00:02:31,250 --> 00:02:33,470
e antes que você pode piscar, o seu
programa já está terminado.

52
00:02:33,470 --> 00:02:36,620
Não é realmente um monte de tempo para tentar
e descobrir o que está acontecendo de errado.

53
00:02:36,620 --> 00:02:40,920
Por isso, para ser realmente capaz de retardar as coisas
para baixo, definindo um ponto de ruptura com b,

54
00:02:40,920 --> 00:02:43,040
e, em seguida, pisar em.

55
00:02:43,040 --> 00:02:46,169
>> Então uma vez que você tenha definido a sua pausa
ponto, você pode executar o programa.

56
00:02:46,169 --> 00:02:47,960
E se você tem qualquer
argumentos de linha de comando,

57
00:02:47,960 --> 00:02:51,610
você especificá-los aqui, e não quando
GDB você digita seu nome do programa.

58
00:02:51,610 --> 00:02:55,980
Você especifica toda a linha de comando
argumentos, tomando r, ou correr,

59
00:02:55,980 --> 00:03:00,270
e, em seguida argumentos de linha de comando que quer
você precisa dentro do seu programa.

60
00:03:00,270 --> 00:03:03,510
Há um número de outro realmente
comandos importantes e úteis

61
00:03:03,510 --> 00:03:04,970
no interior do ambiente de PIB.

62
00:03:04,970 --> 00:03:07,540
Então deixem-me apenas rapidamente
passar por cima de alguns deles.

63
00:03:07,540 --> 00:03:11,320
>> A primeira é a N, que é a abreviação para a próxima,
e você pode digitar próximo em vez de n,

64
00:03:11,320 --> 00:03:12,304
tanto iria funcionar.

65
00:03:12,304 --> 00:03:13,470
E isso é apenas a taquigrafia.

66
00:03:13,470 --> 00:03:17,540
E, como você provavelmente já obtido
acostumado, ser capaz de escrever coisas

67
00:03:17,540 --> 00:03:20,520
mais curto é geralmente melhor.

68
00:03:20,520 --> 00:03:24,100
E o que ele vai fazer é que vai
avançar um bloco de código.

69
00:03:24,100 --> 00:03:26,170
Por isso vai avançar
até que uma chamada de função.

70
00:03:26,170 --> 00:03:28,350
E, em seguida, em vez de
mergulho em que a função

71
00:03:28,350 --> 00:03:33,130
e passando por todos que as funções
código, ele só vai ter a função.

72
00:03:33,130 --> 00:03:34,400
>> A função será chamado.

73
00:03:34,400 --> 00:03:35,733
Ele vai fazer o que seu trabalho é.

74
00:03:35,733 --> 00:03:38,870
Ele irá retornar um valor para
a função que o chamou.

75
00:03:38,870 --> 00:03:42,490
E então você vai passar para a
próxima linha de que a função de chamada.

76
00:03:42,490 --> 00:03:44,555
Se você quiser passo
dentro da função,

77
00:03:44,555 --> 00:03:46,430
em vez de ter apenas
ele executar, especialmente

78
00:03:46,430 --> 00:03:50,004
se você acha que o problema
poderia estar dentro dessa função,

79
00:03:50,004 --> 00:03:52,670
você poderia, é claro, definir uma pausa
ponto no interior dessa função.

80
00:03:52,670 --> 00:03:57,820
Ou, se você já está em execução, você pode
usar s para avançar uma linha de código.

81
00:03:57,820 --> 00:04:01,170
>> Então, isso vai intervir
e mergulhar em funções,

82
00:04:01,170 --> 00:04:04,750
em vez de apenas ter a executar
e continuando na função

83
00:04:04,750 --> 00:04:07,380
que você está em para depuração.

84
00:04:07,380 --> 00:04:09,870
Se você sempre quis saber
o valor de uma variável,

85
00:04:09,870 --> 00:04:12,507
você pode digitar p, ou impressão,
e, em seguida, o nome da variável.

86
00:04:12,507 --> 00:04:15,090
E que irá imprimir a você,
no interior do ambiente de GDB,

87
00:04:15,090 --> 00:04:19,110
o nome da variável, que vocę--
com licença mim-- o valor da variável

88
00:04:19,110 --> 00:04:20,064
que você tenha nomeado.

89
00:04:20,064 --> 00:04:23,230
Se você quiser saber os valores de todas as
variável acessível locais de onde

90
00:04:23,230 --> 00:04:25,970
você está atualmente em sua
programa, você pode digitar informações locais.

91
00:04:25,970 --> 00:04:28,332
É muito mais rápido do que
digitando p e, em seguida, qualquer que seja,

92
00:04:28,332 --> 00:04:30,540
listando todas as
variáveis ​​que você sabe que existem.

93
00:04:30,540 --> 00:04:34,370
Você pode digitar informações locals, e
irá imprimir tudo para você.

94
00:04:34,370 --> 00:04:37,770
Em seguida é bt, que é
curto para Voltar Trace.

95
00:04:37,770 --> 00:04:41,680
Agora, geralmente,
particularmente no início do CS50,

96
00:04:41,680 --> 00:04:44,450
você realmente não vai ter ocasião
usar bt, ou Back Trace,

97
00:04:44,450 --> 00:04:47,860
porque você não está tendo funções
que chamar outras funções.

98
00:04:47,860 --> 00:04:50,450
>> Você pode ter uma página call
função, mas isso é provavelmente isso.

99
00:04:50,450 --> 00:04:53,199
Você não tem outra função que
chamar outra função, que

100
00:04:53,199 --> 00:04:54,880
chama outra função, e assim por diante.

101
00:04:54,880 --> 00:04:57,550
Mas, como seus programas obter mais
complexo, e particularmente

102
00:04:57,550 --> 00:05:00,290
quando você começar a trabalhar
com recursividade, traço de volta

103
00:05:00,290 --> 00:05:05,150
pode ser uma maneira muito útil para deixá-lo
tipo de obter algum contexto para onde

104
00:05:05,150 --> 00:05:06,460
Estou no meu programa.

105
00:05:06,460 --> 00:05:10,590
Então, digamos que você tenha escrito o seu código, e
você sabe que a principal chama uma função

106
00:05:10,590 --> 00:05:14,720
f, que chama uma função
g, o que chama uma função h.

107
00:05:14,720 --> 00:05:17,650
Portanto, temos várias camadas
de nidificação acontecendo aqui.

108
00:05:17,650 --> 00:05:19,440
>> Se você estiver dentro de
seu ambiente GDB,

109
00:05:19,440 --> 00:05:21,640
e você sabe que seu interior
de h, mas você esquecer

110
00:05:21,640 --> 00:05:27,210
sobre o que você tem para onde você
é-- você pode digitar bt, ou traço de volta,

111
00:05:27,210 --> 00:05:32,370
e ele vai imprimir h, g, f principal,
juntamente com algumas outras informações, que

112
00:05:32,370 --> 00:05:35,984
dá-lhe um indício de que, principal OK
chamado f, f chamado g, h g de chamada,

113
00:05:35,984 --> 00:05:37,900
e é aí que eu
Atualmente estou no meu programa.

114
00:05:37,900 --> 00:05:41,380
Por isso, pode ser realmente útil,
especialmente como o enigmático-ness do GDB

115
00:05:41,380 --> 00:05:45,667
torna-se um pouco esmagadora, a
descobrir exatamente onde as coisas estão.

116
00:05:45,667 --> 00:05:48,500
Por último, quando o programa é feito,
ou quando você está feito depurá-lo

117
00:05:48,500 --> 00:05:50,125
e você quer se afastar
a partir do ambiente de GDB,

118
00:05:50,125 --> 00:05:51,940
que ajuda a saber como sair dela.

119
00:05:51,940 --> 00:05:55,500
Você pode digitar q, ou Sair, para sair.

120
00:05:55,500 --> 00:05:59,220
Agora, antes de vídeo de hoje
Preparei um programa de buggy

121
00:05:59,220 --> 00:06:03,900
chamado Buggy1, que eu compilei
a partir de um arquivo conhecido como buggy1.c.

122
00:06:03,900 --> 00:06:06,500
Como você poderia esperar, este
programa é, de facto, buggy.

123
00:06:06,500 --> 00:06:08,990
Algo vai mal
quando eu tentar executá-lo.

124
00:06:08,990 --> 00:06:13,014
Agora, infelizmente, eu inadvertidamente
apaguei meu arquivo buggy1.c,

125
00:06:13,014 --> 00:06:15,930
Então, para mim descobrir
o que está acontecendo de errado com este programa,

126
00:06:15,930 --> 00:06:18,770
Eu vou ter que usar
GDB tipo de cegamente, tentando

127
00:06:18,770 --> 00:06:22,372
para navegar através deste programa para
descobrir exatamente o que está acontecendo de errado.

128
00:06:22,372 --> 00:06:24,580
Mas usando apenas as ferramentas
já aprendemos sobre,

129
00:06:24,580 --> 00:06:27,700
que pode muito bem figura
exatamente o que é.

130
00:06:27,700 --> 00:06:30,740
Então vamos cabeça para
CS50 IDE e dar uma olhada.

131
00:06:30,740 --> 00:06:33,155
OK, por isso estamos aqui na minha
CS50 ambiente IDE,

132
00:06:33,155 --> 00:06:35,697
e eu vou fazer zoom um pouco
assim você pode ver um pouco mais.

133
00:06:35,697 --> 00:06:38,530
Na minha janela do terminal, se eu listo
o conteúdo da minha atual diretor

134
00:06:38,530 --> 00:06:41,250
com ls, vamos ver que eu
tenho um par de arquivos de origem

135
00:06:41,250 --> 00:06:44,982
aqui, incluindo o
anteriormente discutida Buggy1.

136
00:06:44,982 --> 00:06:46,940
O que exatamente acontece quando
Eu tento e executar Buggy1.

137
00:06:46,940 --> 00:06:47,773
Bem, vamos descobrir.

138
00:06:47,773 --> 00:06:52,510
Eu digito barra ponto,
carrinho, e eu pressione Enter.

139
00:06:52,510 --> 00:06:53,670
>> Falhas de segmentação.

140
00:06:53,670 --> 00:06:55,000
Isso não é bom.

141
00:06:55,000 --> 00:06:57,180
Se você lembrar, uma
falha de segmentação tipicamente

142
00:06:57,180 --> 00:07:01,540
ocorre quando acessar a memória
que não estamos autorizados a tocar.

143
00:07:01,540 --> 00:07:03,820
Temos alguma forma atingido
fora dos limites

144
00:07:03,820 --> 00:07:05,995
do que o programa, o
compilador, nos deu.

145
00:07:05,995 --> 00:07:08,310
E assim já que é um
pista para manter-se na caixa de ferramentas

146
00:07:08,310 --> 00:07:10,660
à medida que começamos o processo de depuração.

147
00:07:10,660 --> 00:07:13,620
Algo deu um pouco errado aqui.

148
00:07:13,620 --> 00:07:15,935
>> Tudo bem, então vamos começar
o ambiente GDB

149
00:07:15,935 --> 00:07:19,030
e ver se podemos descobrir
o que exatamente é o problema.

150
00:07:19,030 --> 00:07:21,674
Eu estou indo para limpar a tela do computador,
e eu estou indo para digitar GDB

151
00:07:21,674 --> 00:07:24,340
novamente, para entrar no ambiente GDB,
e o nome do programa

152
00:07:24,340 --> 00:07:27,450
que eu quero depurar, Buggy1.

153
00:07:27,450 --> 00:07:30,182
Recebemos uma pequena mensagem, lendo
símbolos de Buggy1, feito.

154
00:07:30,182 --> 00:07:32,390
Tudo o que significa é que puxou
juntos todo o código,

155
00:07:32,390 --> 00:07:35,570
e agora ele foi carregado em
GDB, e está pronto para ir.

156
00:07:35,570 --> 00:07:37,140
>> Agora, o que eu quero fazer?

157
00:07:37,140 --> 00:07:39,130
Você se lembra o que o
primeiro passo é tipicamente

158
00:07:39,130 --> 00:07:42,540
depois que eu estou dentro deste ambiente?

159
00:07:42,540 --> 00:07:44,540
Com sorte, você referido conjunto
um ponto de ruptura, porque

160
00:07:44,540 --> 00:07:46,240
na verdade, é isso que eu quero fazer.

161
00:07:46,240 --> 00:07:47,990
Agora, eu não tenho o
código fonte para este

162
00:07:47,990 --> 00:07:50,948
na minha frente, o que é, provavelmente,
não é o caso de uso típico, por sinal.

163
00:07:50,948 --> 00:07:52,055
Você provavelmente irá ocorrer.

164
00:07:52,055 --> 00:07:52,680
Então, isso é bom.

165
00:07:52,680 --> 00:07:55,790
Mas supondo que você não fizer isso, o que é
a uma função que você sabe

166
00:07:55,790 --> 00:07:58,880
existe em cada programa C single?

167
00:07:58,880 --> 00:08:04,420
Não importa quão grande ou quão complicado
que é, definitivamente, essa função existe.

168
00:08:04,420 --> 00:08:05,440
Main, certo?

169
00:08:05,440 --> 00:08:08,870
>> Então, não de tudo, nós podemos
definir um ponto de ruptura na principal.

170
00:08:08,870 --> 00:08:12,200
E novamente, eu poderia simplesmente digitar
quebrar principal, em vez de b.

171
00:08:12,200 --> 00:08:14,650
E se você estiver curioso, se você
nunca digitar um comando longo

172
00:08:14,650 --> 00:08:16,800
e, em seguida, perceber que você
digitado a coisa errada,

173
00:08:16,800 --> 00:08:18,770
e você quer se livrar
de todos, como eu fiz,

174
00:08:18,770 --> 00:08:22,029
você pode assumir o controle U, que será
apagar tudo e trazer você de volta

175
00:08:22,029 --> 00:08:23,570
para o início das linhas do cursor.

176
00:08:23,570 --> 00:08:26,569
Um muito mais rápido do que apenas mantenha pressionada a
excluir ou batê-lo vezes grupo

177
00:08:26,569 --> 00:08:27,080
sobre.

178
00:08:27,080 --> 00:08:28,740
>> Então, vamos definir um break point no principal.

179
00:08:28,740 --> 00:08:32,970
E como você pode ver, ele diz que nós temos
definir um ponto de interrupção no arquivo buggy1.c,

180
00:08:32,970 --> 00:08:36,330
e, aparentemente, a primeira linha
de código de linha principal é sete.

181
00:08:36,330 --> 00:08:38,080
Novamente, não temos
o arquivo de origem aqui,

182
00:08:38,080 --> 00:08:40,429
mas eu vou assumir que é
me dizendo a verdade.

183
00:08:40,429 --> 00:08:44,510
E então, eu só estou tentando
e executar o programa, r.

184
00:08:44,510 --> 00:08:45,360
A partir do programa.

185
00:08:45,360 --> 00:08:48,160
Tudo bem, então esta mensagem
é um pouco enigmática.

186
00:08:48,160 --> 00:08:50,160
Mas, basicamente, o que é
acontecendo aqui é que é apenas

187
00:08:50,160 --> 00:08:53,350
me dizendo que eu bati minha pausa
ponto, quebra ponto número um.

188
00:08:53,350 --> 00:08:55,877
>> E então, essa linha de código,
Não existe tal arquivo ou diretório.

189
00:08:55,877 --> 00:08:57,710
A única razão que
Eu estou vendo essa mensagem

190
00:08:57,710 --> 00:09:00,800
é porque eu inadvertidamente
apaguei meu arquivo buggy.c.

191
00:09:00,800 --> 00:09:04,050
Se meu arquivo buggy1.c existiu
no diretório atual,

192
00:09:04,050 --> 00:09:06,920
esse direito linha haveria realmente
me diga o que a linha de código

193
00:09:06,920 --> 00:09:08,214
literalmente lê.

194
00:09:08,214 --> 00:09:09,380
Infelizmente, eu deletei.

195
00:09:09,380 --> 00:09:14,790
Nós vamos ter que tipo de navegar
através deste um pouco mais cegamente.

196
00:09:14,790 --> 00:09:17,330
>> OK, então vamos ver, o que
que eu quero fazer aqui?

197
00:09:17,330 --> 00:09:21,770
Bem, eu gostaria de saber o que locais
talvez variáveis ​​estão disponíveis para mim.

198
00:09:21,770 --> 00:09:23,570
Eu comecei o meu programa.

199
00:09:23,570 --> 00:09:28,515
Vamos ver o que pode ser
já inicializada para nós.

200
00:09:28,515 --> 00:09:31,430
Eu digito moradores Info, não moradores.

201
00:09:31,430 --> 00:09:33,960
Tudo bem, de modo que não faz
dá-me uma tonelada de informações.

202
00:09:33,960 --> 00:09:37,600
Eu poderia tentar e imprimir uma variável,
mas eu não sei todos os nomes de variáveis.

203
00:09:37,600 --> 00:09:39,930
Eu poderia tentar um traço de volta,
mas eu estou dentro de principal,

204
00:09:39,930 --> 00:09:43,710
então eu sei que não fizeram
outra chamada agora função.

205
00:09:43,710 --> 00:09:47,710
>> Então, parece que minhas únicas opções são
usar n ou assim e começar a mergulhar.

206
00:09:47,710 --> 00:09:49,630
Eu vou usar n.

207
00:09:49,630 --> 00:09:51,180
Então eu digito n.

208
00:09:51,180 --> 00:09:53,060
Oh meu Deus, o que está acontecendo aqui.

209
00:09:53,060 --> 00:09:56,260
Programa de sinais recebidos,
SIGSEGV falha de segmentação,

210
00:09:56,260 --> 00:09:57,880
e, em seguida, um monte de coisas.

211
00:09:57,880 --> 00:09:58,880
Eu já estou sobrecarregado.

212
00:09:58,880 --> 00:10:00,980
Bem, há realmente uma
muito a ser aprendido aqui.

213
00:10:00,980 --> 00:10:02,520
Então, o que isso nos diz?

214
00:10:02,520 --> 00:10:09,180
O que isso nos diz é, este programa é
a ponto de, mas não tem ainda, falha seg.

215
00:10:09,180 --> 00:10:12,550
E, em particular, eu vou
para ampliar ainda mais aqui,

216
00:10:12,550 --> 00:10:18,980
é sobre a culpa sobre SEG
algo chamado strcmp.

217
00:10:18,980 --> 00:10:22,705
>> Agora, nós não pode ter discutido
esta função extensivamente.

218
00:10:22,705 --> 00:10:25,580
Mas é-- porque nós não vamos
para falar sobre cada função que

219
00:10:25,580 --> 00:10:28,610
existe no padrão C library--
mas eles estão todos disponíveis para você,

220
00:10:28,610 --> 00:10:32,110
especialmente se você tomar um
olhar para reference.cs50.net.

221
00:10:32,110 --> 00:10:35,000
E strcmp é um realmente poderoso
função que existe dentro

222
00:10:35,000 --> 00:10:38,070
do cabeçalho string.h
arquivo, o que é um cabeçalho

223
00:10:38,070 --> 00:10:41,970
arquivo que é dedicado a funções
que o trabalho com e manipular strings.

224
00:10:41,970 --> 00:10:49,830
>> E, em particular, o que faz é strcmp
compara os valores de duas cordas.

225
00:10:49,830 --> 00:10:54,160
Então, eu estou prestes a falha de segmentação
em uma chamada à strcmp parece.

226
00:10:54,160 --> 00:10:58,530
Eu bati n, e na verdade eu receber a mensagem,
programa terminou com sinal SIGSEGV

227
00:10:58,530 --> 00:11:01,370
falha de segmentação. Então agora
Na verdade, tenho seg criticado,

228
00:11:01,370 --> 00:11:06,479
e meu programa tem bastante
muito eficaz desistido.

229
00:11:06,479 --> 00:11:07,770
Este é o fim do programa.

230
00:11:07,770 --> 00:11:10,370
Ele quebrou, ele caiu.

231
00:11:10,370 --> 00:11:14,740
Então não era muito, mas eu
realmente fez aprender um pouco

232
00:11:14,740 --> 00:11:16,747
a partir desta pouca experiência.

233
00:11:16,747 --> 00:11:17,580
O que aprendi?

234
00:11:17,580 --> 00:11:22,020
Bem, o meu programa falha
praticamente imediatamente.

235
00:11:22,020 --> 00:11:26,300
Meu programa trava em
uma chamada para strcmp, mas eu

236
00:11:26,300 --> 00:11:30,560
Não temos quaisquer variáveis ​​locais na minha
programa no momento em que ele trava.

237
00:11:30,560 --> 00:11:37,320
Então, o que string, ou cordas,
eu poderia ser comparando.

238
00:11:37,320 --> 00:11:42,140
Se eu não tenho qualquer local,
variáveis, você pode

239
00:11:42,140 --> 00:11:45,520
supor que eu have-- lá talvez é uma
variável global, o que poderia ser verdade.

240
00:11:45,520 --> 00:11:47,670
>> Mas geralmente, parece
como eu estou comparando

241
00:11:47,670 --> 00:11:52,070
a algo que não existe.

242
00:11:52,070 --> 00:11:54,130
Então, vamos investigar
que um pouco mais.

243
00:11:54,130 --> 00:11:55,120
Então, eu estou indo para limpar minha tela.

244
00:11:55,120 --> 00:11:57,536
Eu vou sair fora do
Ambiente GDB por um segundo.

245
00:11:57,536 --> 00:12:01,300
E eu estou pensando, OK, então não há
há variáveis ​​locais em meu programa.

246
00:12:01,300 --> 00:12:06,444
Eu me pergunto se talvez eu deveria passar
em uma seqüência de caracteres como um argumento de linha de comando.

247
00:12:06,444 --> 00:12:07,610
Então vamos testar isso.

248
00:12:07,610 --> 00:12:09,020
Eu não fiz isso antes.

249
00:12:09,020 --> 00:12:14,244
>> Vamos ver se talvez se eu executar este programa
com um argumento de linha de comando que funciona.

250
00:12:14,244 --> 00:12:16,140
Huh, não há falha de segmentação.

251
00:12:16,140 --> 00:12:17,870
Ele só me disse que eu percebi isso.

252
00:12:17,870 --> 00:12:19,170
Então, talvez essa seja a solução aqui.

253
00:12:19,170 --> 00:12:27,560
E, de fato, se eu voltar e olhar para
o código-fonte real para buggy1.c,

254
00:12:27,560 --> 00:12:31,180
parece que o que estou fazendo é
Eu estou fazendo uma chamada à strcmp sem

255
00:12:31,180 --> 00:12:34,010
verificar se, de facto, argv [1] existe.

256
00:12:34,010 --> 00:12:36,730
Esta é realmente a
código-fonte para buggy1.c.

257
00:12:36,730 --> 00:12:38,855
Então, o que eu realmente preciso
fazer aqui para corrigir o meu programa,

258
00:12:38,855 --> 00:12:40,835
Supondo que eu tenho a
apresentar na frente de mim, é

259
00:12:40,835 --> 00:12:44,740
apenas para adicionar uma seleção para fazer
certo que argc é igual a 2.

260
00:12:44,740 --> 00:12:47,780
Assim, neste exemplo, mais uma vez, como eu disse,
é um pouco artificial, certo?

261
00:12:47,780 --> 00:12:49,840
Você geralmente não vai
acidentalmente excluir seu código-fonte

262
00:12:49,840 --> 00:12:51,820
e depois tem que tentar
e depurar o programa.

263
00:12:51,820 --> 00:12:53,120
Mas espero que, deu
uma ilustração

264
00:12:53,120 --> 00:12:55,120
dos tipos de coisas que
você poderia estar pensando em

265
00:12:55,120 --> 00:12:56,610
como você está depuração do seu programa.

266
00:12:56,610 --> 00:12:58,760
>> Qual é o estado de coisas aqui?

267
00:12:58,760 --> 00:13:00,510
O que fazer variáveis ​​I
têm acesso a mim?

268
00:13:00,510 --> 00:13:03,600
Onde exatamente é o meu programa
deixar de funcionar, em que linha,

269
00:13:03,600 --> 00:13:05,240
sobre o que chamada para qual função?

270
00:13:05,240 --> 00:13:06,952
Que tipo de pistas que isso me dar?

271
00:13:06,952 --> 00:13:08,910
E isso é exatamente o
tipo de mentalidade que você

272
00:13:08,910 --> 00:13:12,820
deve ser se metendo quando você está
pensando depurar seus programas.

273
00:13:12,820 --> 00:13:13,820
>> Eu sou Doug Lloyd.

274
00:13:13,820 --> 00:13:16,140
Este é CS50.

275
00:13:16,140 --> 00:15:08,642