[? DAN ARMADARAS:?] Hi, Ako [? Dan Armadaras?].
Ngayon, kami ay pagpunta sa ay naghahanap sa pag-debug.
Hindi lamang namin ay pagpunta sa makipag-usap tungkol sa ilang mga pamamaraan,
kundi pati na rin kami ay pagpunta sa tumingin sa ilan sa mga tampok na nakapaloob
sa loob ng CS50 IDE na payagan sa iyo upang madali debug ng isang program.
>> Isa lamang halimbawa ng isang bagay na maaaring maging mali
at ito ay talagang isang bagay na na namin nakita bago.
Sa kasong ito, ito ay isang programa C na tumatanggap ng isang integer mula sa user,
hinahati nito sa pamamagitan ng dalawang, at nagbibigay ng ang output bumalik sa user.
Ngayon mula sa kung ano ang iyong nakita namin mas maaga sa aralin,
Alam namin na ito ay talagang maging sanhi ng tiyak na mga uri ng mga problema sa division
kapag kami ay may kakaibang mga numero.
>> Partikular, kami na lang itapon kahit na ano pagkatapos ng decimal point.
Ngayon, alam namin na ito ang mangyayari sa maging ang kaso.
At kung tumakbo namin ito, maaari naming kumpirmahin ang aming hinala, una, sa pamamagitan ng pag-ipon.
At pagkatapos, sa pamamagitan ng pagpapatakbo at pagpasok ng isang kakaibang number.
>> Ito ay walang bagong.
Ngunit ito ay talagang isang halimbawa ng isang bug na
maaaring umiiral sa loob ng isang mas malaking programa na nagiging mas mahirap na subaybayan down.
Kahit na alam namin kung ano ang isyu ay, ang tunay na puno ng problema
maaaring sinusubukan upang makilala ang partikular na kung saan nangyari ang error,
pagkilala kung ano na ang problema ay, at pagkatapos ay pag-aayos nito.
Kaya nagbibigay ito bilang isang halimbawa ng kung ano ang maaaring maging isang bagay
na namin na malaman ngunit maaaring inilibing sa loob ng iba pang mga elemento ng code.
>> Kaya pagbubukas na ito ng iba pang mapagkukunan code file bilang isang halimbawa,
ang problemang ito division ngayon bahagi ng isang mas malaking programa.
Maaari pa rin ng isang maliit na bit contrived, at kami
Maaari mong ma-madali kilalanin ito, lalo na
dahil kami ay tatalakayin namin ito lamang.
Ngunit maaari naming malaman na ito maaaring umiiral na problema sa isang mas malaking scale.
>> Kung ako sumulat ng libro na ito at ngayon tumakbo ito, ipasok ang isang kakaibang bilang,
maaari naming makita na hindi kami makakuha ng tumpak ang output na maaari naming magkaroon ng inaasahan.
Sa ganitong kaso, maaari nating sabihin na tayo
nais na bilangin ang lahat ng mga numero mula sa isa hanggang sa ilang mga tiyak na numero.
At maaari naming makita na namin magkaroon ng isang iba't ibang mga isyu
dito kung kami ay outputting, i, 0 at 1 kapag nagbibigay kami ng isang input ng 5.
>> Kaya namin na malaman na may problema dito.
Ngunit hindi pa namin maaaring malaman ang tiyak kung saan ang isyu na ito ang tunay na umiiral.
Ngayon ay isa sa mga paraan na maaari naming subukan upang ayusin ito
ay isang bagay na hindi namin nai-ipinakilala sa.
Maaari naming gamitin lamang ito sa isang mas malaking scale.
>> Sa 14 linya, kami ay ito printf function,
na nagpapahintulot sa amin na i-print out ang estado ng iba't-ibang mga piraso ng impormasyon.
At ito ay isang bagay na ikaw ay dapat pagkilos sa loob ng iyong programa
subukan upang malaman kung eksakto kung ano ang nangyayari sa iba't-ibang linya ng code.
Kaya kahit na hindi ito ang final output na namin ang aktwal na
Gusto upang makabuo sa labas ng ang program na ito, kami pa rin
Maaaring magkaroon ng ilang mga debug pahayag kung saan kami
maaari subukan upang malaman kung ano mismo ang ang nangyayari sa loob ng aming mga code.
>> Kaya sa kasong ito, ang gagawin ko printf may tag debug.
Sa kasong ito, ito ay lamang ng isang debug string
na ako up-paglagay upang ito ay nagiging napakalinaw sa output ng aking code
ano ito ay na gusto kong ipakita.
At output dito ang numero na nakalkula namin.
>> Sa kasong ito, maaari ko nais na malaman ang tiyak
kung ano ang nangyayari bago at makalipas ang ilang tiyak na mga pagtutuos.
Kaya maaari ko bang gamitin ang isang printf bago at matapos na linya ng code.
Sa kasong ito, maaari ko kahit gumawa ito ng isang maliit na piraso ng mas malinaw
sa pamamagitan ng pagsasabi debug bago at debug matapos kaya
na hindi ko lituhin ang aking sarili sa maramihang mga linya na tumingin magkapareho.
>> Ngayon kung recompile namin ito at run ito, ipasok ang isang numero tulad ng limang ulit,
maaari naming makita na mayroon kami ngayon output bago at pagkatapos ng
at natagpuan na hindi namin nagawa ang isang malinaw division o malinaw na ang pagkakaroon ng bilang
na gusto naming aktwal na gawin.
Ngayon sa kasong ito, ito ay hindi talagang isang malinaw na output.
Ito ay hindi talagang isang malinaw na resulta na gusto naming sa labas ng mga ito partikular na programa.
>> At ito ay, muli, isang Medyo contrived.
Ngunit, marahil, ang isa sa mga bagay-bagay na maaari naming gawin kung sinabi ng detalye
na gusto naming hatiin ito sa pamamagitan ng 2 at idagdag 1-- kaya sa ibang salita,
gusto naming isalin up-- pagkatapos maaari naming malaman na maaaring namin
gawin sa partikular na bagay, sa kasong ito.
Ngayon dito ay nalalaman natin na tayo ay magiging magagawang magdagdag ng 1 sa aming halved number.
>> Ni-recompile ito Hayaan at kumpirmahin na ito
ay kumikilos ang paraan na gusto naming.
Maaari naming makita na ngayon bago nagkakaroon, kami ay may mga number 5.
Pagkatapos ng pagkakaroon ng, mayroon kaming mga numero 3, na ayon sa aming mga detalye,
ay kung ano ang gusto naming gawin.
Subalit kung tinitingnan namin ang mga output dito, maaari naming
makita na maaari naming magkaroon ng isa pang bug sa kabuuan, na kung saan ay
na kami ay simula ng aming count mula sa 0.
>> Muli Ngayon, ito ay isang bagay na na namin na nakita sa nakalipas na
at maaari naming ayusin medyo madali.
Ngunit sa kasong ito, kami nagkaroon din ng mga benepisyo
ng paggamit ng printf pahayag nang direkta sa loob ng para sa loop
malaman tiyak kung saan error na nangyari.
Kaya printf pahayag ay lubhang kapaki-pakinabang sa pagtulong sa
matukoy mo kung saan, tiyak sa iyong source code,
ng isang tukoy na error ay nangyari.
>> At ito ay mahalaga din upang mapagtanto na, bilang kami ay sumusulat code,
ay magkaroon tayo ng pagpapalagay tungkol sa estado ng isang programa.
O maaaring mayroon kaming pagpapalagay tungkol sa kung ano ang bahagi ng programa
ay talagang tama o maling pagka sa susunod habang binubuo namin sa programa na
at gawin itong bahagi ng isang masalimuot at mas malaking programa
na napagtanto namin na ang ilang mga aspeto ng mga iyon ay talagang maraming surot.
>> Paggamit ng printf ay maaari talagang tulong paliitin at makilala
mga rehiyon ng isang programa na maaaring hindi ay kumikilos nang eksakto ang paraan na aming
asahan, batay sa aming mga palagay.
Ngunit mayroong iba pang mga tool magagamit, pati na rin,
na nagpapahintulot sa amin upang subukan upang figure kung saan ang isang error ay nangyari
at din, partikular, ang mga bagay na ay nangyayari sa loob ng programa.
>> Kaya gamit printf ay tunay kapaki-pakinabang kapag gusto naming
upang makilala ang mga tiyak na lugar ng isang programa na may ilang mga bug.
Ngunit ito rin ay nagiging nakakapagod pagkatapos ng ilang sandali.
Sa kasong ito, ito ay isang relatibong simpleng programa
may isa o dalawang variable.
At ito ay nagiging tunay madali para sa amin upang i-print ang halaga ng mga variable
sa konteksto ng mas malaking programa.
>> Ngunit kami ay maaaring magkaroon ng iba't-ibang programa na may maraming mga variable.
At ito ay maaaring hindi ganap kaya madaling gamitin printf
subukan upang suriin kung ano ang nangyayari sa bawat isa sa mga variable
bilang ng programa ay Isinasagawa.
May isang programa na umiiral tinatawag na isang program debugger.
Sa kasong ito, ang isa na kami paggamit ay ang debugger GNU, o GDB,
na nagbibigay-daan sa amin upang siyasatin ang mga panloob na mga gawain ng isang programa sa isang mas
detalyadong paraan.
>> Maaari naming talagang execute GDB mula sa command line
dito sa pamamagitan ng simpleng pag-type GDB at ang utos na gusto naming upang i-debug.
Sa kasong ito, count.
Ngayon sa kasong ito, maaari naming makita na ito Dinadala tayo nito sa isang prompt na nagsasabing GDB.
At kami ay maaaring aktwal na isakatuparan ang mga utos sa GDB
na talagang simulan ang pagpapatupad ng mga program, itigil ito sa ilang mga punto,
suriin ang mga variable na ito at siyasatin ang mga variable na
umiiral sa programa ng estado sa partikular na sandali,
at iba pa.
Ito ay nagbibigay ng isang pulutong ng kapangyarihan sa atin.
>> Ngunit kaya ito lang ang mangyayari na ang CS50 IDE din
ay nagbibigay ng isang GUI o isang user interface para sa GDB na
ay nagbibigay-daan sa amin upang gawin ito nang hindi nangangailangan ng ang command line interface kahit ano pa man
o sa lahat kahit.
Ang paraan na maaari kong ma-access na ay sa pamamagitan ng paggamit ng pindutan ng debug
sa pinakatuktok ng CS50 IDE.
Ngayon sa nakaraan, kung anong mayroon kami nakita ay na ginagamit namin ang command
line upang ipunin at pagkatapos ay magpatakbo ng isang programa.
>> Ang pindutan na debug ang ginagawa pareho ng mga hakbang na ito.
Ngunit ito ay din ilabas ang tab debugger sa dulong kanan
na nagbibigay-daan sa amin upang masuri ang iba't-ibang ng mga katangian ng programa
tulad ng ito ay Isinasagawa.
Kung nag-click ako debug, sa ganitong kaso, ito ay magdadala up
isang bagong tab sa console window sa pinakadulo ibaba.
>> At makikita mo na ang tab na ito ay may ang ilang mga impormasyon sa pinakatuktok.
At maaari naming kalakhan huwag pansinin ito.
Ngunit ang isa sa mga bagay-bagay na gusto naming mapansin
ay na ito output ang parehong bagay na namin
nais makakuha ng kung sinubukan naming patakbuhin ang gumawa sa ang C programa sa terminal na window.
>> Dito, maaari naming makita na ito ay tumatakbo kumalatong, at ito ay may isang iba't ibang mga flags,
at ito ay pag-ipon ng aming count.c file, na kung saan ay ang mga napiling tab sa oras
na ako hit debug.
Kaya ito ay lubhang kapaki-pakinabang dahil ngayon gamit ang pindutang ito debug,
maaari naming sabay-sabay na sumulat ng libro at pagkatapos ay maipatupad ang mga programa na namin ang aktwal na
nais na tumakbo.
>> Isa sa mga flags na mahalaga, sa kasong ito,
ang tunay na kami ay nasuri gamit para sa pinakamahabang oras
kundi pati na rin ng ginawa sa ilang mga kamay kumakaway [hindi marinig], na
ay ang isang ito dito mismo.
Sa clang, sinasabi nito -ggdb3.
Sa kasong ito, kung ano tayo na nagsasabi sa kumalatong, ang aming tagatala,
ay na gusto naming upang ipunin ang aming programa.
Ngunit din kung ano ang mga tinatawag na impormasyon simbolo
upang ang mga compiler talagang may access sa isang pulutong ng mga pinagbabatayan ng impormasyon
nilalaman sa loob ng programa.
>> Mas partikular, ang bilang ng pag-andar na mayroon akong,
ang mga pangalan ng mga pag-andar, ang mga variable, ang mga uri
na ang mga variable na ito ay, at ng iba't ng iba pang mga bagay na makakatulong sa mga debugger
maisagawa ang operasyon nito.
Ngayon ay mayroong isang bagay pa na Mahalagang banggitin
kapag na tatalakayin natin na tumatakbo isang programa sa ganitong paraan.
>> Pansinin na ito ay may tunay na nagdala up ng isang bagong tab sa aming console
sa ilalim.
Hindi na kami upang makipag-ugnayan nang direkta sa mga terminal na window.
Ngunit ang bagong tab ay talagang isang terminal na window.
Ito lamang ay partikular sa mga tumatakbo program na aming nilikha.
>> Pansinin na sa ibaba, sa kumbinasyon na may ilang output
sa pamamagitan ng kumalatong ang tagatala at GDB, na kung saan maaari naming pangunahin huwag pansinin si,
ito ang tunay na nagpapakita ng output ng ang aming programa sa pinakadulo ibaba.
Ngayon ito ay mahalaga sa mapagtanto na ang isang ito window talaga
ay magpapakita sa iyo ng mga output mula sa iyong programa
ngunit maaari ring tanggapin ang input para sa programang iyon, pati na rin.
>> Kaya notice na nagsasabing mangyaring ipasok ang isang numero,
na kung saan ay ang parehong output na kami ay nagkaroon sa terminal na window bago.
Ngunit ito ay ipinapakita na ngayon sa bagong tab.
Maaari ko input isang numero.
At ito ay tunay na function bilang inaasahan namin
Ipinapakita sa atin ng ating debug, output, ang output na maaaring maraming surot,
bilang namin nakita bago.
At sa pinakadulo ibaba, ito tunay na may ilang karagdagang output
mula GDP lang na nagsasabi na ang program na ito ay nakumpleto.
>> Ngayon bilang na nakita mo sa mga ito partikular na run sa pamamagitan,
ito ay hindi partikular na kapaki-pakinabang dahil kahit
bagaman namin ay ang menu debugger dumating up, ito ay isang programa tumatakbo pa rin.
Sa walang punto ay ito talaga pause pagpapatupad para sa amin
para ma-suriin ang lahat ng mga ang mga variable na nilalaman sa loob.
May isa pang bagay na kailangan nating gawin upang
upang makakuha ng GDB upang makilala na gusto naming upang i-pause pagpapatupad ng programa
at hindi lamang payagan ang mga ito upang magpatuloy normal na gagawin namin sa anumang iba pang mga kaso.
>> Upang i-pause ang pagpapatupad, sa ilang mga tiyak na linya,
kailangan naming gumawa ng kung ano ang tinatawag ng break point.
At isang break point ay napaka madaling nilikha sa ganitong CS50 IDE sa pamamagitan ng pagkuha ng iyong mouse
at pag-click nang direkta sa kaliwa ng ilang tiyak na mga numero ng linya.
Sa sandaling gawin ko na, isang pulang tuldok ay lilitaw, na nagpapahiwatig
na na linya ay isang punto ng pahinga ngayon.
>> At sa susunod na oras na patakbuhin ko GDB, ito titigil execution sa na break point
kapag umabot na ang linya ng code.
Ngayon na ito ay isang mahalagang bagay na napagtanto
na ito ay hindi kinakailangan ang kaso na ang bawat linya ng code
ay talagang mapuntahan.
Kung ako ay upang lumikha ng isang function hanggang dito, para example-- void f--
at lamang gawin ng isang line print here-- kumusta world-- kung hindi ko tawagan ang function na ito,
ito ay ang kaso, kung magpakita ako ng break point dito,
ang function ay hindi kailanman ay tatawagin.
At dahil dito, ang partikular na punto ng pahinga
hindi kailanman ay talagang i-pause pagpapatupad ng programa.
>> Kaya sabihin natin na tama ba akong lumikha ng ng break point sa ilang mga linya ng code
na tunay na pinaandar.
Ngayon sa kasong ito, ito ay ang unang linya sa pangunahing pag-andar.
Kaya ito ay tiyak na ang kaso na, sa lalong madaling simulan ko pagpapatupad,
ay naabot ang unang linya.
GDB ay i-pause execution.
At pagkatapos, ako ay ma- makipag-ugnayan sa debugger.
>> Maaari kang magtakda ng maramihang mga linya ng breakpoints, kung iyong nais.
Maaari din naming lumikha ng isang line up dito sa segment na ito ng code
na hindi kailanman ay naabot.
At maaari din namin-set ang isa pa sa ibaba.
Ang dahilan na gusto namin gusto mong gawin ito bibigyan namin ng
pumunta sa isang maliit na mas kaunti detalye sa ilang sandali lamang.
Kaya sa ngayon, hayaan huwag paganahin ang sa akin lamang ang mga karagdagang mga puntos break
sa gayon maaari naming tumingin sa kung ano ang mangyayari kapag ako ay may isang solong pahinga
point sa aking programa.
Ginawa kong ilang mga pagbabago sa programa na ito.
Kaya kailangan ko upang i-save ito.
Ako ay i-click ang debug sa gayon ay maaari ko simulan ang compilation at pagkatapos ay
pagpapatupad ng debugger.
>> Makikita natin na, pagkatapos ng sandali, ang line na napili namin bilang ang break
point ay naka-highlight sa dilaw.
Maaari din namin mapansin na sa kanang itaas sa debug panel
na ang mga icon pause ay nakabukas sa isang maliit na icon ng pag-play.
Nangangahulugan ito na kami ay may pause pagpapatupad, sa mga partikular na kaso.
At ang pagpindot sa pindutan na Play Gusto daan sa amin upang ipagpatuloy ang pagpapatupad
sa mga tiyak na punto.
>> Pansinin na may isang pares ng mga iba pang pindutan na magagamit sa debug panel,
din.
Tumawid, na kung saan ay nagbibigay-daan sa akin upang execute na isang linya ng code
at tumawid sa na linya sa susunod na isa, na kung saan, sa kasong ito,
ay nangangahulugan na ang printf pahayag ay naisakatuparan.
At ito ay pagkatapos i-pause pagpapatupad sa 13 na linya, tulad ng sa gayon.
>> At mayroon din ng isang hakbang sa function, kung saan
ay kapaki-pakinabang kung ako ay nilikha ng iba pang mga function sa ibang lugar sa source code.
At gusto ko sa hakbang sa mga function sa halip na
execute na pag-andar bilang isang buo.
Ngunit kami ay tumingin nang higit pa sa mga hakbang sa function na sa isang sandali lamang.
Ngayon pansinin ang ilang mga iba pang bagay na ang tunay na umiiral sa loob ng debug panel.
>> Mayroon kaming na ito panel na tinatawag na ang tumawag stack, na nagpapakita sa amin
kung saan eksakto kami.
Sa kasong ito, natin sa loob sa mga pangunahing function.
Ang aming script ay tinatawag count.c.
At mangyari namin upang maging sa 13 column ng isa, linya, na kung saan
ay tiyak kung ano ang naka-highlight na rehiyon ng source code nagpapahiwatig, pati na rin.
>> Ngayon pansinin na ito ay nagpapakita rin sa ilalim ng seksyon ng mga lokal na variable
lahat ng mga variable na umiiral sa loob ng function na ito.
Ito ay mahalaga na tandaan na ang lahat ng mga variable
lalabas sa mga lokal na variable na seksyon sa loob ng isang function,
kahit na bago ang mga ito ay tinukoy.
Maaari naming makita dito na kami ay may isang variable tinatawag num, ay may isang default na halaga ng 0,
at ito ay uri ng int.
>> Ngayon bago namin talagang magpasimula lahat ng mga variable,
kami ay hindi kinakailangang garantisadong upang makita ang isang halaga ng 0.
At depende sa iba pang mga pagbitay na ikaw ay ginanap
at ang estado ng iyong memorya kapag aktwal mong patakbuhin ang program na ito,
maaari mong makita na ikaw ay hindi makita ang mga halaga ng 0
at, sa halip, ang ilang mga iba pang nakatutuwang mga numero.
>> Ngunit huwag mag-alala tungkol sa na.
Hindi ito ay magiging may-katuturang hanggang ang tunay na ikaw magpasimula ng halaga.
Ngayon sa kasong ito, maaari naming makita na Ako ay ginanap sa ilang mga output.
At ako, sa ngayon, naka-pause execution.
Ngunit sa kasong ito, kung ano ang Gusto ko talagang gawin
ay sa ngayon tumawid sa linyang ito ng code sa gayon ay maaari ko talaga
query ng user para sa na int na gusto naming gamitin sa aming programa.
>> Ngayon sa kasong ito, kapag ang Pindutin ko hakbang sa ibabaw, ang paunawa
na ang I-pause o sa halip ng Resume button ay nagbago sa Pause button
dahil ang code na ito ay aktwal na e-execute.
Anong nangyayari ngayon ay na ito ay
naghihintay para sa amin na input ng ilang impormasyon bilang maaari naming makita sa pamamagitan ng aming output text
sa pinakadulo ibaba.
>> Kaya ngayon, ito ay hindi tunay na naka-pause,
kahit na ito, uri ng, lilitaw na dahil wala ang nangyayari.
Ngunit ito lamang ang kaya mangyayari na sa aking mga tiyak na kaso sa 13 na linya,
Hinihintay ko input ng user.
At kaya GDB ay hindi magagawang upang siyasatin isang programa tulad ng ito ay tumatakbo.
>> Ngayon ang susunod na oras na ipasok ko ang ilang mga input-- kaya ko na ipasok na number 5,
bilang namin nakita sa past-- hit Return, at kami
mapapansin na, agad-agad, GDB pause at, muli, nagha-highlight ang susunod na linya.
Ngunit mapansin na ngayon, bilang isang resulta ng aming inputting ng isang halaga,
Na-update namin ang halaga na loob ng ating mga lokal na variable, na
ay lubhang kapaki-pakinabang na malaman ang tiyak kung ano ang numero na nasa memory.
>> Ngayon ay maaari kong payagan ang program na ito upang magpatuloy naglalaro hanggang sa katapusan ng pagpapatupad nito
sa pamamagitan ng pagpindot ang Ipagpatuloy.
Maaari naming makita na masyadong mabilis ay ang tapusin ang program Isinasagawa
na may parehong output na tayo ay nagkaroon ng bago, isinara ang debugger,
at ngayon ang program na ito ay tumigil sa ganap na.
>> Ipakita ko na lamang para sa mga mga layunin ng kung ano ang nakikita
mangyayari kapag aktwal na namin pindutin ang Ipagpatuloy.
Ngunit namin talagang ay pagpunta sa nais na bumalik sa programa na ito
upang maaari naming subukan na debug tiyak kung ano ang nangyayari.
Ngayon na ako gamit ang debugger, upang ako'y Hindi kailangan ang mga debug printf pahayag.
>> Kaya maaari kong tanggalin ang mga ito bilang aking gagawin ngayon lamang upang bumalik sa aming simple code
na nagkaroon kami ng ilang sandali ang nakalipas.
Ngayon kapag ako i-save ang programa at execute ito,
ito ay, muli, pumunta sa na unang basagin point na ako ay on line 11.
At kukunin ko na magagawang upang siyasatin ang aking mga variable na gusto kong gawin.
>> Kaya ito lang ang mangyayari na ito bahagi ay hindi masyadong kawili-wili,
At alam ko na pupuntahan ko upang i-print out ang pahayag na ito.
Mangyaring ipasok ang isang numero.
At pagkatapos ay, alam ko na pupuntahan ko upang hilingin sa user para sa na integer.
Kaya marahil, talagang gusto kong ilipat ang aking basagin point nang kaunti pa pababa.
>> Maaari mong alisin break points sa pamamagitan ng pag-click, muli, direkta
sa kaliwa ng na numero ng linya.
Iyon pulang tuldok ay mawawala, na nagpapahiwatig na na break point ay nawala ngayon.
Ngayon sa kasong ito, pagpapatupad ay naka-pause.
At kaya ito ay hindi tunay na pagpunta sa ipagpatuloy sa mga partikular na pagkakataon.
Ngunit maaari kong i-set ng isang break ituro ang isang maliit na piraso mamaya.
>> At kapag ngayon ipagpatuloy ko ang aking code, ito ay ipagpatuloy at sabihin sa
ang punto ng na break point.
Muli, ako pindutin ang Ipagpatuloy.
Hindi mukhang tulad ng anumang bagay ang nangyayari.
Ngunit iyon ay dahil ang aking code ay naghihintay para sa input.
Ako ay ipasok ang isang numero 5, pindutin ang Enter, at ngayon ang susunod na break point ay pindutin.
>> Ngayon sa kasong ito, ito ay ang linya ng code
na, bago, alam namin nangyari na mayroong bug.
Kaya sabihin suriin kung ano ang mangyayari sa partikular na punto ng oras.
Kapag ang isang linya ay naka-highlight, ito line ay hindi pa naisakatuparan.
Kaya sa kasong ito, maaari naming makita na mayroon akong isang numero, na
Mayroon akong isang integer na tinatawag na num na may isang halaga 5.
At ako pagpunta sa ay gumaganap ang ilang mga matematika sa na numero.
>> Kung ako na hakbang sa paglipas na, maaari naming mapapansin na ang halaga para sa num
ay nagbago sa alinsunod sa mga arithmetic na aktwal na namin ang nagawa mo.
At ngayon na kami ay sa loob ng mga ito para sa loop
o ngayon na ang para sa loop mismo ay naka-highlight,
nakita namin na kami ay may isang bagong variable na tinatawag na i na
ay pagpunta sa magamit sa na para sa loop.
>> Ngayon tandaan bago na ako nabanggit na minsan ikaw ay
pagpunta upang makita ang ilang mga uri ng mga loko numero bilang default bago ang numerong iyon
o variable na talagang nasimulan.
Maaari naming makita na tiyak dito sa variable na ito
tinatawag i, na kung saan ay hindi pa nasimulan
sa oras ng pag-highlight.
Ngunit maaari naming makita na ito ay may ilang mga numero ng na hindi talaga namin inaasahan.
>> Iyon ang OK.
Huwag mag-alala tungkol sa mga ito dahil kami ay hindi tunay
initialize ang numerong iyon hanggang ako hakbang sa linyang ito at ang halaga
i ay nasimulan sa ang halaga ng 1.
Kaya upang makita na na talagang ang kaso, ni hakbang sa ibabaw ipaalam.
Maaari naming ngayon makita na na line ay pinaandar.
At ngayon kami ay highlight ang linyang ito printf.
>> At maaari naming ngayong makita kung paano ang aming mga halaga ng ako ay nagbago at 3 sa paglipas ng panahon.
Ito ay lubhang kapaki-pakinabang na gawin, sa katunayan, ay sa hakbang sa paglipas ng mga linya ng paulit-ulit.
At maaari mong mahanap kung ano ang tunay ang mangyayari sa loob ng iyong para sa loop
at kung ano ang mangyayari sa mga variable sa loob ng na para sa loop
pati na pagpapatupad ng programa nangyayari sa isang hakbang sa isang pagkakataon.
>> Ngayon sa puntong ito, ako stepped sa ibabaw lamang ng sapat na
na ako ngayon sa dulo ng aking programa.
Kung ako na hakbang sa paglipas na, ito ay talagang itigil execution
tulad ng nakita natin sa nakaraan.
Hayaan akong i-restart ito, pa muli, kaya na maaari kong ituro sa ibang bagay out,
din.
>> Sa kasong ito, ito ay ngayon humihingi sa akin, muli,
para sa isang numero, na Ako ay, muli, ipasok.
Ngunit oras na ito, pupuntahan ko na ipasok sa isang mas malaking bilang upang ang para sa loop
ay umulit pa ulit.
Sa kasong ito, pupuntahan ko upang ipasok ang isang halaga ng 11.
>> Ngayon muli dahil gusto ko i-set ng break point sa 15 na linya,
ito ay pagpunta sa i-highlight na line.
Maaari naming makita na ang aming number 11 ay tama
kinakatawan sa aming mga lokal na variable.
Pagtapak sa paglipas na, maaari naming ngayon panoorin kung ano ang mangyayari sa aming mga halaga ng i
bilang namin magpatuloy sa loob ng mga ito para sa loop.
Ito ay makakakuha ng incremented sa bawat oras na namin maabot ang tuktok ng na para sa loop.
>> Ngayon ay isa sa mga bagay na maaaring maging kapaki-pakinabang na gawin sa panahon ng pagganap
ng programang ito ay para sa akin na ang tunay baguhin ang mga variable gitna ng agos upang makita
ano ang mangyayari sa aking programa.
Sa kasong ito, maaari ko talagang i-click ang double ang halaga.
Pansinin na ito ay nagiging isang patlang ng teksto.
>> Ngayon ay maaari kong ipasok ang iba't ibang Pinahahalagahan kabuuan
upang makita kung paano kumikilos ang aking programa kapag ako ay nagbago na variable.
Ngayon sa kasong ito, ang mga variable Naglalaman i ngayon ang halaga 10.
Ngunit ang programa pa rin ang naka-pause sa execution.
Kapag hakbang ko sa loob, nakikita ko na ang halaga i, na ipinasok ko bilang 10,
ay hindi mas malaki kaysa sa halaga ng num, na agad na nagiging sanhi ng para sa loop
upang ihinto Isinasagawa.
>> Ngayon na ay hindi lamang ang dahilan kung bakit gusto mo
nais na baguhin ang mga variable sa lugar.
Maaari mong aktwal na nais subukan na baguhin ito sa gayon
na maaari mong patuloy pagpapatupad ng isang loop
o kaya na maaari mong baguhin ilang mga halaga bago ito
umabot ng ilang mga tiyak na hanay ng arithmetic kayo tungkol sa mga gumanap.
>> Kaya ngayon na ang tunay na palitan namin ang halaga ng i bilang ng programa ay Isinasagawa,
ito ang sanhi ng para sa loop upang tumigil maaga dahil, ang lahat ng isang biglaang, i
nangyari na mas malaki kaysa sa halaga ng num, ibig sabihin na iyon para sa loop
hindi na kinakailangan na pinaandar.
Dagdag dito, ang nangyari ito upang maging ang kaso na binago namin ang halaga ng i
kapag ang linya 17 ay naka-highlight, na kung saan ay ang punto sa oras
na ang para sa loop execution ay tunay na sinusuri.
>> Kung may nagbago ko ang halaga ng i sa isang iba't ibang mga linya, sabihin 19,
sana ay nakita namin ang iba't ibang pag-uugali dahil line 19 gagawin
naglapat bago ang loop kondisyon ay muling sinuri.
Ngayon sa puntong ito, Ako, muli, sa dulo ng programang ito.
At maaari ko bang payagan ang mga ito upang magpatuloy sa payagan ang aking mga programa na umalis natural.
Subalit mayroong isang pares ng mga bagay na mahalaga upang mag-alis
mula sa partikular na talakayan.
Kailangan mong suriin iyong sariling pagpapalagay
tungkol sa kung paano ang mga code ay dapat na kumikilos.
Anumang oras sa tingin mo na ang ilang mga piraso ng code ng alam mo ang mangyayari sa trabaho,
na maaaring maging isang pulang bandila upang pumunta bumalik at suriin, at tiyaking
na ang iyong mga palagay ng paano na code ay operating
ay tunay na tunay na kung paano ito ay ipinahayag sa iyong source code.
>> Ngunit kahit na higit pa sa point, kapag kami ay gumagamit ng debugger,
maaari kang maglagay ng breakpoints iba't-ibang linya ng code,
na kung saan ay magiging sanhi ng debugger upang i-pause ang pagpapatupad sa bawat isa sa mga linya
sa gayon maaari mong suriin ang mga memory o kahit na baguhin ito sa lugar.
At muli, tandaan na maaari mong lumikha ng maramihang breakpoints upang ikaw
Maaari ring ipagpatuloy ang pagpapatupad, laktawan sa paglipas ng malaking bahagi ng code,
at makikita ito awtomatikong i-pause sa susunod na break point.
>> Mayroon talagang mas advanced mga tampok ng debugger, pati na rin.
Ngunit kami ay may sa sumangguni sa iyo sa ilang mga kasunod na mga video
upang tunay manunudyo bukod kung paano na gamitin ang mga partikular na pag-andar.
Para sa ngayon, salamat sa iyo napaka para sa panonood.
At magandang debugging luck.