>> DOUG LLOYD: Lahat ng karapatan GDB.
Ano ang eksaktong ito?
Kaya GDB, na ang ibig sabihin para sa GNU Debugger,
ay isang tunay na kahanga-hangang tool na maaari naming gamitin upang matulungan kaming i-debug ang aming programa,
o malaman kung saan ang mga bagay ay pagpunta mali sa aming programa.
GDB ay amazingly malakas na, ngunit ang output at pakikipag-ugnayan sa mga ito
ay maaaring maging isang maliit na piraso cryptic.
Ito ay karaniwang isang tool command line, at maaari itong itapon ang isang pulutong ng mga mensahe sa iyo.
At ito ay maaaring uri ng mahirap na parse ang eksaktong kung ano ang nangyayari sa.
Sa kabutihang palad, nagsagawa kami ng mga hakbang upang ayusin ang problemang ito para sa iyo
habang nagtatrabaho ka sa pamamagitan ng CS50.
Kung ikaw ay hindi gumagamit ng mga graphical debugger, na aking kasamahan Dan
Armandarse sinalita ng lubos ng kaunti tungkol sa isang video na
ay dapat na higit dito sa ngayon, na maaaring kailangan mo
na gamitin ang mga command line tool upang gumana sa GDB.
Kung ikaw ay nagtatrabaho sa CS50 IDE, hindi mo na kailangan na gawin ito.
Ngunit kung ikaw ay hindi nagtatrabaho sa CS50 IDE,
marahil gamit ang isang bersyon ng CS50 Appliance,
o sa iba pang Linux operating system na may GDB-install sa mga ito,
maaaring kailangan mong gamitin ang mga kasangkapan sa command line.
>> At dahil maaari ka kailangang gawin iyan,
kapaki-pakinabang upang maunawaan kung paano lamang GDB gumagana mula sa linya ng command.
Ngunit muli, kung ikaw ay gamit ang CS50 IDE, ikaw
maaaring gamitin ang mga graphical debugger na ay binuo sa mga IDE.
Kaya upang makakuha ng mga bagay na nangyayari sa GDB, upang simulan ang pag-debug
proseso ng isang partikular na programa, kailangan lahat ng gagawin mo
ay i-type sinundan GDB sa pamamagitan ng pangalan ng programa.
Kaya halimbawa, kung ang iyong programa ay hello, gusto mo type GDB hello.
>> Kapag ginawa mo na, ikaw ay pagpunta upang hilahin pataas ang GDB kapaligiran.
Ang iyong prompt ay magbabago, at sa halip ng pagiging kung ano ito ay karaniwang
ay kapag nag-type ka ng mga bagay sa utos line-- ls,
cd-- lahat ng iyong mga tipikal Linux command, ang iyong prompt
ay magbabago sa, marahil, ang isang bagay tulad ng mga panaklong GDB panaklong.
Iyan na ang iyong bagong GDB prompt, dahil ikaw ay nasa loob ng GDB kapaligiran.
Kapag sa loob ng na kapaligiran, mayroong dalawang pangunahing utos
na ikaw ay malamang na gamitin ang sa mga sumusunod na order.
>> Ang una ay b, na kung saan ay maikli para sa break.
At pagkatapos mong i-type b, karaniwan kang type ang pangalan ng isang function,
o kung mangyari mong malaman sa paligid ng kung ano ang line number
ang iyong programa ay nagsisimula kumikilos ang isang maliit na kakaiba,
Maaari mong i-type ang isang linya number doon rin.
Ano b, o break, ginagawa ay nagbibigay-daan ito sa iyong programa
upang magpatakbo ng hanggang sa isang tiyak na punto, sa makatuwid baga'y ang pangalan ng function
na tinukoy mo o ang linya number na iyong tinukoy.
>> At sa puntong iyon, ito i-freeze ang pagpapatupad.
Ito ay isang talagang magandang bagay, dahil minsan sa pagpapatupad ay frozen,
maaari kang magsimula sa masyadong mabagal magbasa-basa sa inyong programa.
Karaniwan, kung kayo ay tumatakbo iyong mga programa, ang mga ito ay medyo maikli.
Karaniwan, nagta-type ka dot slash ano man ang pangalan ng iyong programa ay, pindutin ang Enter,
at bago ka makakapag-blink, ang iyong programa ay naka-tapos na.
Ito ay hindi tunay na isang pulutong ng mga oras upang subukan at malaman kung ano ang pagpunta mali.
Kaya ito ay talagang para ma-mabagal bagay down sa pamamagitan ng pagtatakda ng isang break point na may b,
at pagkatapos ay kumikilos.
>> Pagkatapos ay sa sandaling naitakda mo na ang iyong mga break point, maaari mong patakbuhin ang program.
At kung mayroon kang anumang mga argumento command line,
na tinukoy mo ang mga ito dito, hindi kapag nagta-type ka GDB ang iyong pangalan ng program.
Tukuyin mo ang lahat ng mga linya ng command argumento sa pamamagitan ng pagkuha r, o tumakbo,
at pagkatapos ay kahit anong command line argument kailangan mo sa loob ng iyong programa.
Mayroong isang bilang ng iba pang mga tunay na mahalaga at kapaki-pakinabang na mga utos
sa loob ng kapaligiran ng GDP.
Kaya ipaalam sa akin mabilis lang balikan ang ilan sa mga ito.
>> Ang una ay n, na kung saan ay maikli para sa susunod, at maaari mong i-type susunod na sa halip ng n,
parehong gumagana.
At ito lang ang shorthand.
At habang ikaw ay marahil mo na tapat na paraan ginagamit sa, kawalan ng kakayahang mag-type ng mga bagay
mas maikli ay karaniwang mas mahusay.
At kung ano ang gagawin nito ay ito makikita humakbang pasulong isang bloke ng code.
Kaya ito ay sumulong hanggang ang isang function ng tawag.
At pagkatapos ay sa halip ng diving sa na function na
at pagpunta sa pamamagitan ng lahat ng na pag-andar code, ito lang ay ang function.
>> Ang function na ay tinatawag na.
Ito ay gawin ang anumang trabaho nito ay.
Ito ay bumalik ng isang halaga sa ang function na tinatawag na ito.
At pagkatapos ay makikita mo ilipat sa sa susunod na linya ng na function na pagtawag.
Kung gusto mo sa hakbang sa loob ng function,
sa halip ng pagkakaroon lamang ito execute, lalo na
kung sa tingin mo na ang problema maaaring kasinungalingan sa loob ng na function,
maaari mong, siyempre, i-set ng isang break point sa loob ng na function.
O kung ikaw ay nagpapatakbo, maaari mong gamitin s sa hakbang pasulong sa isang linya ng code.
>> Kaya ito ay hakbang sa at sumisid sa pag-andar,
sa halip ng na lang ay ang maipatupad at patuloy sa sa pag-andar
na ikaw ay para sa pag-debug.
Kung gusto mo mang malaman sa halaga ng isang variable,
Maaari mong i-type p, o I-print, at pagkatapos ay ang pangalan ng variable.
At iyon ay i-print out sa inyo, sa loob ng GDB kapaligiran,
ang pangalan ng variable, na you-- excuse me-- ang halaga ng variable
na iyong na may pangalang.
Kung nais mong malaman ang mga halaga ng bawat lokal na variable access mula sa kung saan
kayo ay kasalukuyang nasa iyong programa, maaari mong i-type lokal na impormasyon.
Ito ay isang pulutong ng mas mabilis kaysa pag-type p at pagkatapos ay kahit na ano,
listahan ng lahat ng variable na alam mo umiiral.
Maaari ninyong ilagay ang mga lokal na impormasyon, at ito ay i-print out ang lahat ng bagay para sa iyo.
Susunod ay bt, na kung saan ay maikli para sa Back bakas.
Ngayon, sa pangkalahatan, lalo na sa unang bahagi ng CS50,
Hindi mo ba talagang ay magkakaroon ng pagkakataon gamitin bt, o Back bakas,
dahil hindi nagkakaroon ka ng mga pag-andar na tumawag sa iba pang mga pag-andar.
>> Maaari mong magkaroon ng pangunahing ng isang tawag function, ngunit iyan ay marahil ito.
Wala kang na ang ibang mga function pagtawag sa ibang function, kung saan
tawag sa isa pang pag-andar, at iba pa.
Ngunit bilang makakuha ng mas maraming ng iyong mga programa mahirap unawain, at lalo
kapag nagsimula ka nang magtrabaho may recursion, pabalik trace
ay maaaring maging isang talagang kapaki-pakinabang na paraan upang ipaalam sa iyo uri ng makakuha ng ilang mga konteksto para sa kung saan
Kasama ko sa aking programa.
Kaya sabihin mo na nakasulat ang iyong code, at alam mo na ang mga pangunahing tawag sa isang function
f, na tawag ng isang function g, na tawag ng isang function h.
Kaya kami ay may ilang mga layer ng pugad ng pagpunta sa dito.
>> Kung ikaw ay sa loob ng iyong GDB kapaligiran,
at alam mo ang iyong loob ng h, ngunit nakalimutan mo
tungkol sa kung ano ang nakuha mo sa kung saan mo are-- maaari mong i-type bt, o trace back,
at ito ay i-print out h, g, f main, sa tabi ng ilang mga iba pang impormasyon, na
nagbibigay sa iyo ng isang palatandaan na, OK main tinatawag na f, f tinatawag g, g tinatawag na h,
at na kung saan ako kasalukuyang am sa aking programa.
Kaya ito ay talagang kapaki-pakinabang, lalo na bilang ng misteryosong-Ness ng GDB
nagiging isang maliit na napakalaki, upang alamin kung saan ang mga bagay ay.
Panghuli, kapag ang iyong programa ay tapos na, o kapag tapos ka na sa pag-debug ito
at gusto mo sa hakbang ang layo mula sa GDB kapaligiran,
makakatulong ito upang malaman kung paano makakuha ng out ng mga ito.
Maaari kang mag-type q, o tumigil, upang makakuha ng out.
Ngayon, bago video ngayong araw Inihahanda ko ang isang programa sa maraming surot
tinatawag buggy1, na aking naipon mula sa isang file na kilala bilang buggy1.c.
Bilang maaari mong asahan, ito programa ay sa katunayan maraming surot.
Isang bagay na napupunta mali kapag sinusubukan kong at patakbuhin ito.
Ngayon, sa kasamaang palad, hindi ko sinasadyang tinanggal ang aking buggy1.c file,
kaya sa order para sa akin upang malaman kung kung ano ang nangyayari mali sa programang ito,
Pupunta ako sa may upang gamitin ang GDB uri ng walang taros, sinusubukan
upang mag-navigate sa pamamagitan ng programang ito sa malaman kung ano mismo ang pagpunta mali.
Ngunit gamit lamang ang mga tool na aming natutunan tungkol sa,
Maaari naming medyo marami figure kung ano mismo ang ito ay.
Kaya ng tumuloy sa ipaalam CS50 IDE at may hitsura.
OK, kaya kami dito sa aking CS50 IDE kapaligiran,
at kukunin ko na mag-zoom in sa isang maliit na piraso upang maaari mong makita ang isang maliit na higit pa.
Sa aking terminal na window, kung ako listahan ang mga nilalaman ng aking kasalukuyang director
may ls, makikita namin makita na ako magkaroon ng isang pares ng mga mapagkukunan ng mga file
dito, kabilang ang dati tinalakay buggy1.
Ano ang eksaktong napupunta sa kapag Subukan ko at tumakbo buggy1.
Ng malaman rin ipaalam.
Nagta-type ako tuldok slash, maraming surot, at ako pindutin ang Enter.
>> Segmentation pagkakamali.
Iyan ay hindi mabuti.
Kung isipin mo, isang segmentation fault karaniwang
nangyayari kapag namin ma-access memory na hindi namin pinapayagan sa pagpindot.
Kahit papaano naabot na namin ang sa labas ng hangganan
ng kung ano ang mga programa, ang mga tagatala, ay nagbigay sa amin.
At kaya na iyon ang isang bakas na panatilihin sa Toolbox
habang sinisimulan namin ang proseso ng pag-debug.
Mayroong nangyaring hindi isang maliit na mali dito.
>> Lahat ng karapatan, kaya sabihin start up ang GDB kapaligiran
at tingnan kung maaari naming malaman kung ano ang eksaktong ang problema ay.
Pupunta ako upang i-clear ang aking screen, at pupuntahan ko upang i-type GDB
muli, upang ipasok ang GDB kapaligiran, at ang pangalan ng programa
na gusto kong i-debug, buggy1.
Kumuha kami ng isang maliit na mensahe, pagbabasa simbolo mula buggy1, tapos na.
Lahat ay nangangahulugan na ito ay nakuha sa sama ang lahat ng mga code,
at ngayon itong ma-load sa GDB, at ito ay handa na upang patakbuhin.
>> Ngayon, ano ang gusto kong gawin?
Natatandaan mo pa ba kung ano ang mga unang hakbang ay karaniwang ay
kapag ako'y loob ng environment na ito?
Sana, sinabi mo i-set ng pahinga point, dahil
sa katunayan na ito ay kung ano ang gusto kong gawin.
Ngayon, hindi ko na kailangang ang source code para sa mga ito
sa harap ko, na kung saan ay marahil hindi ang tipikal na kaso ng paggamit, sa pamamagitan ng ang paraan.
Ikaw ay malamang.
Kaya na mabuti.
Ngunit sa pag-aakala na hindi mo, kung ano ang ang isang function na alam mo
umiiral sa bawat solong programa C?
Hindi mahalaga kung paano malaki o kung paano kumplikado ito ay, tiyak na ito ay umiiral na function.
Main, di ba?
>> Kaya hindi pagtupad sa lahat ng iba pa, maaari naming magtakda ng isang break point sa main.
At muli, maaari lamang i-type ako masira pangunahing, sa halip ng b.
At kung gusto mong malaman, kung ikaw kailanman-type ang isang mahabang utos
at pagkatapos ay mapagtanto na kayo nai-type sa maling bagay,
at nais mong makakuha ng alisan ng lahat bilang ko lang ginawa,
maaari kang kumuha ng Control U, na kung saan ay tanggalin ang lahat ng bagay at dalhin mo sa likod
sa simula ng cursor mga linya.
Ang isang pulutong ng mas mabilis kaysa lamang hold down ang tanggalin, o sa pagpindot ito ng isang beses na bungkos
over.
>> Kaya makikita namin magtakda ng isang break point sa main.
At tulad ng makikita mo, sinasabi nito na namin magtakda ng isang punto ng pahinga sa file buggy1.c,
at tila ang unang linya ng code ng main ay pitong linya.
Muli, wala tayong ang source file dito,
ngunit kailangan ko ipinapalagay na ito ay na nagsasabi sa akin ang katotohanan.
At pagkatapos, ako lamang sinusubukan at patakbuhin ang programa, r.
Simula ng program.
Lahat ng karapatan, kaya ang mensaheng ito ay isang maliit na misteriyoso.
Pero talaga kung ano ang nangyayari dito ay ito lamang
na nagsasabi sa akin hit ko na ang aking pahinga point, break point number 1.
>> At pagkatapos ay, na ang linya ng code, walang ganitong file o direktoryo.
Ang tanging dahilan na Nakakakita ako ng mensahe na
ay dahil hindi ko sinasadyang tinanggal ang aking buggy.c file.
Kung umiiral ang aking buggy1.c file sa kasalukuyang direktoryo,
na line doon ay aktwal na sabihin sa akin kung ano ang linya ng code
literal bumabasa.
Sa kasamaang palad, tinanggal ko ito.
Kami ay pagpunta sa may sa uri ng mag-navigate sa pamamagitan ng isang maliit na ito ng mas maraming walang taros.
>> OK, ang makita kaya hayaan, kung ano ang gusto kong gawin dito?
Well, Gusto kong malaman kung ano ang mga lokal na variable siguro ay makukuha sa akin.
Sinimulan ko na ang aking programa.
Tingnan natin kung ano ang maaaring maging Ipaalam nasimulan nang dahil sa atin.
Nagta-type ako naninirahan ang Info, walang mga lokal.
Lahat ng mga karapatan, sa gayon ay hindi bigyan ako ng isang tonelada ng mga impormasyon.
Kaya kong subukan at i-print out ang isang variable, ngunit hindi ko alam ang anumang mga pangalan ng variable.
Maaari ko bang subukan ang isang bakas sa likod, ngunit ako sa loob ng main,
kaya alam ko na hindi ko ginawa ibang mga function ng tawag ngayon.
>> Kaya ganito ang hitsura ng aking lamang na pagpipilian ay gamitin n o kaya at simulan sa sumisid in.
Pupunta ako upang gamitin n.
Kaya ko type n.
Oh aking sus, kung ano ang nangyayari dito.
Program natanggap signal, SIGSEGV segmentation fault,
at pagkatapos ng buong bungkos ng mga bagay-bagay.
Ako na bumagsak.
Well, may tunay na isang pulutong na natutunan dito.
Kaya kung ano ang ibig sabihin sa amin?
Ano ito ay nagsasabi sa amin ay, ang program na ito ay tungkol sa, ngunit ay hindi pa, seg fault.
At sa partikular, pupuntahan ko upang mag-zoom in kahit pa dito,
ito ay tungkol sa seg fault tungkol isang bagay na tinatawag strcmp.
>> Ngayon, maaaring hindi namin napag-usapan mga function na ito nang husto.
Ngunit ito is-- dahil hindi namin pagpunta makipag-usap tungkol sa bawat function na
umiiral sa standard C library-- ngunit ang mga ito ay magagamit sa lahat ng sa iyo,
lalo na kung ikaw ay kumuha ng isang tingnan reference.cs50.net.
At strcmp ay isang talagang malakas function na ay umiiral sa loob
ng string.h header file, na kung saan ay isang header
file na ito ay nakatuon sa mga function na gumagana sa at paggamit ng mga string.
>> At sa partikular, kung ano ang strcmp ay ay ikinukumpara ito sa mga halaga ng dalawang string.
Kaya ako si segmentation fault sa isang tawag sa strcmp tila.
Pindutin ko n, at sa katunayan na nakukuha ko ang mensahe, program tinapos sa SIGSEGV signal
segmentation fault. At ngayon Ako ang tunay na may seg faulted,
at ang aking mga programa ay may pretty marami mabisa ibinigay up.
Ito ay ang dulo ng programa.
Ito Nasira, nag-crash ito.
Kaya ay hindi isang pulutong, ngunit ako talaga ay malaman ng lubos ng kaunti
mula sa maliit na karanasan.
Ano ang aking natutunan?
Well, nag-crash ang aking programa medyo marami agad.
Aking mga programa nag-crash sa isang call to strcmp, ngunit ako
walang anumang lokal na mga variable sa aking programa sa oras na nag-crash ito.
Kaya kung ano ang string, o mga string, kaya kong posibleng maging paghahambing.
Kung hindi ko magkaroon ng anumang lokal na variable, maaari ka
magpalagay na have-- ako doon siguro ay isang global variable, na maaaring maging totoo.
>> Ngunit sa pangkalahatan, tila tulad ako ng paghahambing
sa isang bagay na ay hindi umiiral.
Kaya sabihin imbestigahan na ang isang maliit na karagdagang.
Kaya ako pagpunta upang i-clear ang aking screen.
Pupunta ako sa umalis sa labas ng GDB na kapaligiran para sa isang segundo.
At ako ay nag-iisip, OK, kaya may walang lokal na mga variable sa aking programa.
Siguro kung siguro ako dapat na ipasa ang sa isang string bilang isang argument command line.
Kaya subukan lang ni this out ipaalam.
Hindi ko pa tapos na ito bago.
>> Tingnan natin kung siguro kung nagpatakbo ako ng programang ito may isang argument command line ito gumagana.
Huh, walang segmentation fault doon.
Sinabi lang sa akin na ang korte ito.
Kaya marahil na ang fix dito.
At sa katunayan, kung pumunta ako pabalik at tumingin sa ang aktwal na source code para sa buggy1.c,
tila na parang ang ginagawa ko ay Ako sa paggawa ng isang tawag sa strcmp walang
check kung sa katunayan argv [1] ay umiiral na.
Ito ay talagang ang source code para buggy1.c.
Kaya kung ano ang tunay na kailangan upang gawin dito upang ayusin ang aking mga programa,
ipagpapalagay na nakatanggap ako ng maghain sa harap ko, ay
upang magdagdag lamang ng isang tseke upang gumawa ng siguraduhin na ang argc ay katumbas ng 2.
Kaya halimbawa na ito, muli, tulad ng sinabi ko, Medyo contrived, di ba?
Ikaw ay karaniwang ay hindi pagpunta sa sinasadyang tanggalin ang iyong source code
at pagkatapos ay upang subukan ang at i-debug ang program.
Ngunit sana, nagbigay ito ikaw ay isang paglalarawan ng halimbawa
ng mga uri ng mga bagay-bagay na Maaaring ikaw ay nag-iisip tungkol
bilang ka ng pag-debug ang iyong programa.
>> Ano ang estado ng mga gawain dito?
Ano variable gagawin ko Mayroon accessible sa akin?
Saan eksakto ang aking programa pag-crash, sa kung ano ang line,
sa kung ano ang tawag sa kung ano ang function?
Anong uri ng mga pahiwatig ang na ibigay sa akin?
At iyon mismo ang uri ng mindset na kayo
dapat na pagkuha sa kapag ikaw ay nag-iisip tungkol sa pag-debug ang iyong programa.
>> Ako Doug Lloyd.
Ito ay CS50.