[Powered by Google Translate] GDB, el Projecte GNU Debugger, és una potent eina de depuració per a C,
juntament amb molts altres idiomes.
Que li permet furgar dins dels seus programes en C mentre estan executant,
i també li dóna l'oportunitat de veure exactament el que succeeix
quan es bloqueja el programa.
És molt enginyós, no?
GDB és programari lliure, i s'executa en els models més usuals UNIX i
Basats en Windows sistemes operatius, de manera que és una eina molt estesa.
>> Vostè ha d'aprendre a estimar-la.
Pros GDB tindrà un temps molt més fàcil rastrejar errors
que els de sortir del pas amb conjectures
i una quantitat infinita d'enunciats impressions.
GDB és una eina de línia de comandes, el que significa que pot interactuar amb ell en una terminal
donant ordres a través del teclat en lloc de botons fent clic amb el ratolí.
>> Per iniciar GDB, que, literalment, només gdb escriu a l'indicador i premeu Enter.
Veuràs unes línies impreses a la pantalla
mostrant la versió del BGF que s'està executant,
seva informació de drets d'autor, i al final veurà l'indicador GDB: (gdb).
Això li permet saber que el BGF està llest per als comandaments.
En aquest punt, la cosa més important que saber fer és deixar de fumar.
Afortunadament, això és bastant simple.
La comanda quit fa precisament això.
Com a mètode abreujat, pot simplement usar q també.
Tan divertit com arrencar el BGF i ​​després deixar de fumar immediatament és,
Parlem ara una mica sobre l'ús de GDB per ajudar a depurar un programa.
>> Per començar, tinc un programa aquí a factorial.c
que rep un enter i tracta de calcular el factorial.
En cas que vostè no ha vist abans factorials o no els recordo,
El factorial del nombre n és igual al producte de n - (n - 1), (n - 2), i així successivament -
fins arribar a 1.
Per tant, el factorial de 3 és 3 * 2 * 1, o 6,
i el factorial de 4 és 4 * 3 * 2 * 1, o 24.
El factorial de zero és un cas estrany, és 1,
i els factorials dels nombres enters negatius no estan definides.
De tota manera, hi ha alguna cosa en el meu programa factorial és funky.
Quan ho executo, imprimeix nombres estranys que no tenen res a veure amb els factorials.
>> Per tant, podem usar GDB per ajudar a entendre el que està passant.
GDB opera en arxius executables,
que són els arxius binaris produïts pel procés de compilació.
És a dir, no es pot executar en el nostre GDB. Co H fitxers de codi font com factorial.c.
Volem que s'executi en un sol lloc factorial.
Si el programa requereix cap argument de línia d'ordres,
aquí és on ens agradaria donar més detalls.
En aquest cas, factorial no requereix cap argument de línia d'ordres,
així que només has de escriure d'execució o r per abreujar.
>> Això iniciarà el programa executant factorial.
Quan el programa deixa de funcionar, em posaré el meu GDB demanarà de nou.
Bé, intentarem fer el mateix una altra vegada, factorial de 4.
Molt bé, veiem que estem rebent el mateix tipus d'escombraries aquí a GDB.
Ara que el programa ha acabat,
no podem entrar i accedir al seu estat,
per la qual cosa haurem de començar a funcionar una altra vegada abans de poder veure el que està succeint.
No obstant això, necessitem una manera de detenir mentre està a la meitat de la seva carrera.
>> Per això, s'utilitza el que s'anomena un punt d'interrupció.
Punts d'interrupció dir GDB per aturar el programa en una determinada funció o línia de codi font
de manera que es pot examinar l'estat del programa,
els valors de les variables, l'estat de la memòria i tal, en aquest punt.
Com que no se sap molt bé on van les coses malament,
>> Només vull començar a depurar la dreta en el començament,
just quan comença principal.
Anem a establir un punt d'interrupció al principi del principal mitjançant la comanda break.
També es pot utilitzar per abreujar b break.
Ara anem a llançar el programa torni a funcionar.
Aquí estem en el començament de la principal, igual que el BGF ens diu.
La línia de codi que està a punt d'executar, però encara no ha
és la línia printf.
Podem dir GDB per executar aquesta línia de codi i anar a la següent línia
amb la següent comanda o núm.
>> Molt bé, ara GDB ens diu que estem en la línia de getInt.
Sé que sembla que la línia printf no s'ha executat
ja que no es veu "Introduïu un nombre enter positiu" lletra a la pantalla,
però s'ha executat realment.
El que estem veient és el sistema operatiu suprimir qualsevol cosa per escrit a la pantalla
fins que absolutament ha de fer, que per què la depuració amb impressions
de vegades pot semblar poc fiable.
De tota manera, anirem de nou a la següent línia de codi i entrar en un int.
Un cop més, anem a tipus 4.
Així que això sembla estrany. Estem en la línia 12 d'acord amb GDB,
però la següent línia que està a punt d'executar és només una clau de tancament.
>> Això només significa que estem al final d'un cicle, el nostre cicle do while, de fet,
GDB i ens està dient que la condició de terminació, és a dir, ni més ni menys que zero,
executarà a continuació.
Si alguna vegada es posa una mica confús,
podem treure el codi font en GDB amb la llista d'ordres o l.
Això imprimeix el codi font
que està centrat al voltant de la línia que estem actualment.
Si teclegem llista o l altra vegada, anem a veure el següent conjunt de línies d'impressió.
Podem fer això fins que arribem al final de l'arxiu.
>> Per tornar a on estàvem, podem subministrar llista amb un nombre de línia,
en aquest cas, la línia 12.
De tota manera, seguirem endavant.
Ara que estem en el bucle 4.
Anem a fer de la nostra variable num conté 4.
Fem això amb la impressió, op, comanda.
Per tant, el BGF ens diu quin número és, en efecte emmagatzemar 4, tal com esperàvem.
Els $ 1 que imprimeix GDB és una variable GDB especial
que ja està configurat per emmagatzemar el número 4 també.
Pot passar per alt aquesta per ara, però aquestes variables GDB vénen en súper pràctic
en casos més avançats quan es desitja recordar el que has fet en el passat.
De tota manera, seguir endavant amb el següent, veiem que comencem a anar a través del bucle for.
Seguim per aquí amb n bits a poc.
En lloc d'escriure n cada vegada, també pot simplement prem enter.
Quan es prem enter sense escriure res, el BGF només repeteix la comanda anterior.
Així que ara ens hem topat amb l'anomenada printf.
Sembla que hem fet passat pel nostre bucle for 4 vegades,
que és el que volem fer per tal de multiplicar per 1, 2, 3, i 4.
>> Tot sembla que està funcionant,
excepte quan colpegem propera vegada tenim aquesta enorme quantitat en lloc de 24.
Si s'imprimeix el valor de p factorial utilitzant,
veiem que factorial té aquest nombre massiu-hi.
Alguna cosa definitivament va malament.
En aquest punt, però, que són gairebé al final del programa,
i és massa tard per arreglar qualsevol cosa.
>> No obstant això, es pot reiniciar el programa escrivint r altra vegada i després i per confirmar.
Ara estem de tornada al nostre punt d'interrupció al principi del principal.
Sabem que tot sembla estar bé amb la lectura en el núm.
perquè puguem anar per davant amb n.
Alternativament, pot establir un nou punt d'interrupció després que el cicle do while
i salta allà. Farem això.
Sembla que la línia 14 arriba just després del bucle.
Anem a posar un breakpoint allà.
És una bona pràctica per especificar el nom del fitxer en la comanda breakpoint
des GDB pot confondre si està treballant amb diversos arxius.
Per moure per davant d'aquest punt d'interrupció, usarem la comanda continuï o c.
>> Bé, aquí estem en el bucle for.
Anem a anar en la línia 1 més el bucle for,
i llavors començarem variables d'impressió per veure què està passant.
Anem a fer de i és en realitat 1, com s'esperava.
Sí, això és tot bo.
I factorial però?
Vaja, això no és bo.
Tenim un nombre negatiu gran aquí.
Com va passar això?
Bé, si mirem cap enrere en el codi,
es veu que mai ho inicialitzat, així que només tinc escombraries en aquest país.
Això definitivament desfer del nostre càlcul.
>> Afortunadament, no hem de deixar GDB per solucionar aquest problema.
Podem inicialitzar la dreta i fixar-la en el codi més endavant mitjançant la comanda d'impressió.
Anem a inicialitzar a 1, ja que els factorials de zero i 1 són dos 1,
i si ho inicialitza a zero, llavors sempre acabaria amb el zero com el nostre resultat.
Pot establir qualsevol variable d'aquesta manera, que és súper pràctic.
Ara, continuarem amb el nostre programa.
Anem a fer de tot està on ha d'estar.
Num ha de ser de 4, que hauria de ser 1, i factorial ha de ser 1 també.
Podem abreujar aquest procés i imprimir totes les nostres variables locals
amb els vilatans informació super-útil de comandament,
que imprimeix tots els nostres considerades en l'estudi les variables locals.
De tota manera, sembla que tot està a punt per sortir.
>> Anem a fer un altre go-around del bucle per curar-se.
Bé, tot es veu molt bé.
Ara podem usar la comanda Continuar per passar a la final.
Sweet! 4 factorial imprimir 24 com s'esperava.
Ara podem arreglar això en el nostre codi.
En lloc de deixar fora de GDB, utilitzarem una altra fitxa terminal per fer això.
Tornant al nostre compte GDB, ara hem de tornar a compilar el nostre executable.
Una de les millors coses de GDB és que vostè no necessita sortir de GDB a executar make.
Així que no deixen de colpejar els punts de tall d'edat,
anem a desactivar amb ell, l'has endevinat, desactivar comandes.
Això desactivarà tots els nostres punts d'interrupció.
Ara, podem reiniciar el programa amb r i assegurar-se que tot està bé.
Sembla que tot està a punt per sortir.
Factorial de 4 imprimeix 24, igual que el que pensàvem.
GDB és una de les eines més útils que tens al caixa d'eines.
>> Hi ha coses que una tona més que pots fer amb GDB,
molt més del que pots fer amb les impressions simples.
La propera vegada que el seu programa no és fer el que volgués,
proveu d'executar GDB per esbrinar el que està passant dins.
Amb una mica de pràctica, vostè serà capaç d'aprofundir en el teu error en cap moment.
El meu nom és Nate Hardison. Això és CS50.