[Powered by Google Translate] GDB, o GNU Project Debugger, é uma poderosa ferramenta de depuração para C,
juntamente com muitas outras línguas.
Ele permite que você bisbilhotar dentro seus programas de C, enquanto eles estão em execução,
e dá-lhe também a oportunidade de ver exatamente o que acontece
quando falha de seu programa.
É muito bacana, certo?
GDB é um software livre, e funciona em muitos UNIX popular e
Sistemas operacionais baseados no Windows, por isso é uma ferramenta muito difundida.
>> Você deve aprender a amá-lo.
Prós GDB ter um tempo muito mais fácil rastrear erros
do que aqueles que inverter a ordem e usando suposições
e quantidades infinitas de declarações da impressão.
GDB é uma ferramenta de linha de comando, o que significa que você pode interagir com ela em um terminal
emitir comandos através do teclado em vez de botões clicando com o mouse.
>> Para iniciar o GDB, você literalmente apenas gdb no prompt e tecle enter.
Você verá algumas linhas impressas para a tela
mostrando a versão do GDB que você está executando,
sua informação de copyright, e no final você vai ver o prompt GDB: (gdb).
Isso permite que você saiba que o GDB está pronto para comandos.
Neste ponto, a coisa mais importante que saber fazer é parar de fumar.
Felizmente, isso é muito simples.
O comando quit faz exatamente isso.
Como um atalho, você pode apenas usar q também.
Tão divertido quanto arrancar GDB e prontamente parar de fumar é,
Vamos agora falar sobre o uso de GDB para ajudar a depurar um programa.
>> Para começar, eu tenho um programa aqui em factorial.c
que recebe um int e tenta calcular o seu fatorial.
No caso você não tenha visto antes fatoriais ou não se lembra deles,
O fatorial do número n é igual ao produto de n - (n - 1), (n - 2), e assim por diante -
até que você bata um.
Portanto, o factorial de 3 é 3 * 2 * 1, ou 6,
e que o fatorial de 4 é 4 * 3 * 2 * 1, ou 24.
O fatorial de zero é um caso estranho, é um,
e os fatoriais de inteiros negativos não estão definidas.
De qualquer forma, algo sobre o meu programa fatorial é funky.
Quando eu executá-lo, ele imprime os números estranhos que nada têm a ver com fatoriais.
>> Assim, podemos usar o GDB para ajudar a descobrir o que está acontecendo.
GDB opera em arquivos executáveis,
que são os ficheiros binários produzidos pelo processo de compilação.
Isto é, não podemos correr o GDB em nosso c. Ou. Arquivos de origem h código como factorial.c.
Nós queremos executá-lo em apenas fatorial vez.
Se o programa necessário quaisquer argumentos de linha de comando,
este é o lugar onde nós especificá-los.
Neste caso, fatorial não necessita de quaisquer argumentos de linha de comando,
então apenas digitar corrida ou r para breve.
>> Isto irá iniciar a execução do programa fatorial.
Quando o programa pára de correr, eu vou buscar o meu GDB pedir de volta.
Ok, vamos tentar a mesma coisa de novo, fatorial 4.
Tudo bem, vemos que estamos recebendo o mesmo tipo de lixo aqui no GDB.
Agora que o programa terminou,
não podemos entrar e acessar qualquer de seu estado,
por isso precisamos iniciá-lo funcionando novamente antes que possamos ver o que está acontecendo.
No entanto, precisamos de uma maneira de pará-lo enquanto ele está no meio de sua execução.
>> Para isso, usamos o que é chamado um ponto de interrupção.
Breakpoints dizer GDB para pausar o programa em uma determinada função ou linha de código fonte
de modo que podemos verificar o estado do programa,
os valores de variáveis, o estado da memória e como, neste ponto.
Desde que eu realmente não sei onde as coisas estão indo mal,
>> Eu só quero começar a depuração logo no início,
direito ao principal começa.
Vamos definir um ponto de interrupção no início da principal usando o comando break.
Nós também podemos usar b para abreviar pausa.
Agora vamos iniciar o programa funcionando novamente.
Aqui estamos no início do principal, assim como o GDB nos diz.
A linha de código que está prestes a executar, mas ainda não
é a linha printf.
Podemos dizer GDB para executar esta linha de código e ir para a próxima linha
com o próximo comando ou n.
>> Tudo bem, agora GDB diz-nos que estamos na linha de GetInt.
Eu sei que parece que a linha printf não correr
desde que não vemos "Digite um inteiro positivo" impressão na tela,
mas se realmente executado.
O que estamos vendo é o sistema operacional suprimir qualquer coisa escrita para a tela
até que seja absolutamente necessário, que por depuração com impressões
às vezes pode parecer pouco confiáveis.
Enfim, vamos mais uma vez ir para a próxima linha de código e entrar em um int.
Novamente, vamos tipo 4.
Portanto, este parece estranho. Estamos na linha 12 de acordo com o GDB,
mas a próxima linha que está prestes a executar é apenas uma cinta encaracolado.
>> Isso só significa que estamos no final de um ciclo, o nosso fazer enquanto laço de fato,
GDB e está nos dizendo que a condição de término, ou seja, nada menos que zero,
será executado em seguida.
Se isso nunca fica um pouco confuso,
podemos puxar o código fonte em GDB com a lista ou o comando l.
Este imprime o código fonte
que está centrado em torno da linha que estamos no momento.
Se tipo de lista ou l novamente, vamos ver o próximo conjunto de linhas impressas.
Podemos fazer isso até chegarmos ao final do arquivo.
>> Para voltar para onde estávamos, nós podemos fornecer lista com um número de linha,
neste caso, linha 12.
Enfim, vamos seguir em frente.
Agora estamos no loop 4.
Vamos ter certeza de que a nossa variável num contém 4.
Fazemos isso com a impressão, ou p, de comando.
Então, o GDB nos diz que num é de fato armazenar 4, como esperávamos.
Os US $ 1 que imprime GDB é uma variável GDB especial
que já está definido para armazenar o número 4 também.
Você pode ignorar isso por enquanto, mas essas variáveis ​​GDB vêm em super handy
nos casos mais avançados, quando você quer se lembrar do que você fez no passado.
De qualquer forma, se movendo com a seguinte, vemos que começar a se mover através do loop for.
Vamos continuar por aqui com n bits por pouco.
Em vez de digitar n cada vez, você também pode simplesmente pressionar enter.
Quando você bate entrar sem digitar nada, GDB apenas repete o comando anterior.
Então agora nós batemos a chamada printf.
Parece que temos de fato passou por nosso laço for 4 vezes,
que é o que nós queremos fazer, a fim de multiplicar por 1, 2, 3, e 4.
>> Tudo parece que está funcionando,
exceto quando bateu próximo novamente temos essa grande número em vez de 24.
Se imprimir o valor de p usando fatorial,
vemos que fatorial tem esse enorme número nele.
Algo está definitivamente errado.
Neste ponto, no entanto, que são quase no final do programa,
e é tarde demais para corrigir alguma coisa.
>> No entanto, pode reiniciar o programa, digitando r novamente e então y para confirmar.
Agora estamos de volta ao nosso ponto de interrupção no início da principal.
Sabemos que tudo parece estar bem com a leitura no n.
para que possamos ir em frente com n.
Como alternativa, pode-se definir um novo ponto de interrupção após o fazer loop while
e saltar lá. Vamos fazer isso.
Parece que a linha 14 vem logo após o loop.
Vamos definir um ponto lá.
É uma boa prática para especificar o nome do arquivo neste comando breakpoint
desde GDB pode ficar confuso se você está trabalhando com vários arquivos.
Para avançar deste ponto de interrupção, vamos usar o comando continue ou c.
>> Ok, aqui estamos no loop.
Vamos linha 1 mais no loop for,
e depois nós vamos começar variáveis ​​de impressão para ver o que está acontecendo.
Vamos ter certeza de que eu é de fato um, como esperado.
Sim, isso é tudo de bom.
E sobre fatorial embora?
Uau, isso não é bom.
Temos um grande número negativo aqui.
Como isso aconteceu?
Bem, se olharmos para o código,
vemos que nunca inicializado, então nós só tenho lixo lá.
Isso definitivamente vai jogar fora o nosso cálculo.
>> Felizmente, não temos de deixar GDB para corrigir isso.
Podemos inicializá-lo aqui e corrigi-lo no código mais tarde usando o comando de impressão.
Nós vamos inicializá-lo para 1 desde os fatoriais de zero e um são ambos 1,
e se inicializá-lo para zero, então nós sempre acabam com zero, como o nosso resultado.
Você pode definir qualquer maneira esta variável, que é super acessível.
Agora, vamos continuar o nosso programa.
Vamos ter certeza que tudo está onde deveria estar.
Num deve ser de 4, eu deveria ser 1, e fatorial deve ser um também.
Podemos atalho este processo e imprimir todos os nossos variáveis ​​locais
com os super-úteis locais comando info,
que imprime todos os nossos no escopo de variáveis ​​locais.
De qualquer forma, parece que tudo é bom para ir.
>> Vamos fazer um outro go-around do circuito só para ter certeza.
Ok, tudo parece ótimo.
Agora podemos usar o comando continuam a ir até o fim.
Sweet! Fatorial 4 impressas 24 como esperado.
Agora podemos ir corrigir isso no nosso código.
Em vez de sair fora do GDB, vamos usar outra guia terminal para fazer isso.
Voltando ao nosso guia GDB, agora precisamos recompilar nosso executável.
Uma das melhores coisas sobre o GDB é que você não precisa sair de GDB para executar fazer.
Assim que nós não continuar batendo os pontos de interrupção de idade,
vamos desabilitá-los com o, você adivinhou, desativar comando.
Isto irá desativar todos os nossos pontos de interrupção.
Agora, podemos reiniciar o programa com R e se certificar que tudo está bem.
Parece que tudo o que é bom para ir.
Fatorial de 4 imprime 24, assim como pensávamos.
GDB é uma das ferramentas mais úteis que você tem em sua caixa de ferramentas.
>> Há coisas que uma tonelada mais você pode fazer com o GDB,
muito mais do que você pode fazer com impressões simples.
Da próxima vez que o programa não é fazer o que você quiser,
tente executar GDB para descobrir o que está acontecendo lá dentro.
Com um pouco de prática, você vai ser capaz de pesquisar na sua bug em nenhum momento.
Meu nome é Nate Hardison. Este é CS50.