[? DAN ARMADARAS:?] Hi, Én vagyok [? Dan Armadaras?].
Ma megyünk vizsgálni hibakeresés.
Nem csak megyünk beszélni néhány technikát,
hanem fogunk nézni néhány jellemzőjét,
a CS50 IDE, amelyek lehetővé teszik könnyedén debug programot.
>> Csak egy példa valami, ami elromolhat
és ez valóban valami hogy mi már látott.
Ebben az esetben, ez egy C program amely elfogadja egy egész szám a felhasználó,
osztja azt a két, és biztosítja a kimenet vissza a felhasználónak.
Most attól, amit láttunk korábban előadások,
tudjuk, hogy ez valóban okozhat bizonyos típusú megosztottság problémák
amikor már a páratlan számok.
>> Pontosabban azt fogjuk csak kidobni semmit a tizedesvessző után.
Most már tudjuk, hogy ez előfordul, hogy a helyzet.
És ha futtatni, meg tudjuk erősíteni, a gyanú, első, összeállítása.
És akkor, a futás és belépő egy páratlan szám.
>> Ez nem újdonság.
De ez valójában egy Például egy hiba, ami
létezhet egy nagyobb program hogy egyre nehezebb a nyomára bukkanni.
Annak ellenére, hogy tudjuk, mi a probléma van, az igazi dolog bökkenője
Lehet, hogy próbálják azonosítani ahol kifejezetten a hiba,
meghatározzuk, hogy mit, hogy probléma van, majd rögzítése.
Tehát ezt az példáján hogy mi lehet valami
hogy már tudjuk, de lehet eltemetve belüli egyéb elemeinek a kódot.
>> Tehát nyitó ezt más forrásból kód fájlt példaként,
Ez a megosztottság probléma most része egy nagyobb program.
Mégis talán egy kicsit kicsit kiagyalt, és mi
képes lehet könnyen azonosítani, főleg
hiszen mi csak megvitatni ezt.
De tudjuk kitalálni, hogy ez a probléma létezik a nagyobb léptékben.
>> Ha tudom lefordítani ezt, és most futtatni, adja meg páratlan szám,
azt látjuk, hogy nem kapunk pontos A kimeneti, hogy mi is várható.
Ebben a konkrét esetben, azt mondhatjuk, hogy mi
akarja számolni az összes számot egytől néhány konkrét számot.
És azt látjuk, hogy mi hogy a különböző kérdések
itt, ha mi vagyunk kimenetre, egyszerűen, 0 és 1, ha adunk egy bemeneti 5.
>> Szóval már tudjuk, hogy van itt egy kis probléma.
De mi nem tudjuk pontosan Ez a kérdés valóban létezik.
Most az egyik módja, hogy próbáljuk kijavítani ezt
van valami, hogy már már bevettek.
Mi csak használni, nagyobb léptékben.
>> On line 14, van ez a printf függvény,
amely lehetővé teszi számunkra, hogy nyomtassa ki az állam A különböző információk.
És ez a valami, amit generáljon a programon belül
hogy megpróbálja kitalálni, hogy pontosan mi történik különböző sornyi kódot.
Tehát akkor is, ha ez nem a végeredményt, hogy mi valójában
szeretnénk termelni ki ez a program, még mindig
Lehet, hogy néhány hibakeresés nyilatkozatok, ahol
próbálja meg kitalálni, hogy pontosan történik belül a kódunkat.
>> Tehát ebben az esetben, úgy lesz printf a hibakeresés tag.
Ebben az esetben, ez az Csak egy hibakereső húr
hogy én fel-üzembe, így válik nagyon világos a kimeneti kódomat
mi az, hogy meg akarok mutatni.
És kimeneti ide száma általunk számított.
>> Ebben az esetben talán szeretném tudni, pontosan
mi történik előtt és miután néhány konkrét számításokat.
Szóval lehet, hogy használja a printf előtt és ezt követően sor kódot.
Ebben az esetben is tudtam hogy ez egy kicsit világosabb
kimondásával hibakeresés előtt és a hibakeresés után így
hogy ne keverjük össze magam Több vonal, hogy nézd azonos.
>> Most, ha újrafordítani ezt, és fuss ez adja meg a számot, mint öt újra,
azt látjuk, hogy van most kimenet előtt és után
és kiderül, hogy nem tettünk egyértelmű szétválás vagy egyértelmű, amelynek a számát
hogy igazából szeretnék csinálni.
Most ebben az esetben, ez az Nem igazán világos kimenet.
Ez nem igazán egyértelmű eredményre jutni akarunk E sajátos programot.
>> És ez, ismét egy kicsit kiagyalt.
De talán, az egyik dolog, hogy tudnánk tenni, ha a specifikáció mondta
hogy szeretnénk osztani ezt 2, és adjunk hozzá 1-- így más szóval,
akarjuk, hogy kerek up-- majd megismerjük, hogy mi lehet
Ehhez bizonyos dolgot, ebben az esetben.
Most itt tudjuk, hogy mi lesz képes felvenni 1 mi felére csökkent száma.
>> Nézzük újrafordítani ezt és megerősíti, hogy ez a
viselkedik az úton, amit szeretnénk.
Láthatjuk, hogy most, mielőtt amelynek megvan a száma 5.
Miután megvan a 3-as szám, amely szerint a specifikáció,
az, amit szerettünk volna csinálni.
De ha megnézzük a kimenet van, amit lehet
látom, hogy talán van egy másik bug összesen, ami
hogy kezdjük a száma 0.
>> Most megint ez valami hogy láttuk az elmúlt
és ki tudjuk javítani nagyon könnyen.
De ebben az esetben, mi is volt az előny
használata a printf kifejezést közvetlenül belül a for ciklus
tudni, hogy pontosan honnan hogy a hiba esemény történt.
Tehát printf nyilatkozatok nagyon hasznos a
meghatározhatja, hová, Pontosan a forráskódban,
adott hiba történt.
>> És az is fontos, hogy észre hogy amint írunk kódot,
talán van feltételezések az állam a program.
Vagy talán van feltételezések arról, hogy mi része a programnak
valójában helyes vagy helytelen, ha későbbiekben építünk, hogy a program
és hogy ez része egy összetett és nagyobb program
hogy rájövünk, hogy bizonyos szempontból Az, hogy valójában hibás.
>> Printf nem igazán segít leszűkítheti és azonosítani
A régiók egy program, amely nem kell viselkedik pontosan úgy, hogy
várni, mi alapján feltételezéseket.
De van más szerszámok rendelkezésre, valamint,
amelyek lehetővé teszik számunkra, hogy megpróbálja kitalálni hogy ha egy hiba történt,
és azt is, konkrétan, milyen dolgokat történnek belül a program.
>> Tehát használ printf nagyon hasznos, ha azt akarjuk,
azonosítani konkrét területeken olyan program, amely valamilyen hiba.
De ez is lesz unalmas egy idő után.
Ebben az esetben, ez egy viszonylag egyszerű program
csak egy-két változó.
És nagyon egyszerűvé válik számunkra, hogy nyomtassa ki az értéke azokat a változókat
keretében a nagyobb program.
>> De lehet, hogy egy másik program, amely sok változó.
És lehet, hogy nem elég így könnyen használható printf
hogy próbálja értékelni, hogy mi történik hogy minden egyes ilyen változók
mivel a program végrehajtása.
Van egy program, ami létezik úgynevezett debugger programot.
Ebben az esetben, az egyik, hogy mi lesz használatát a GNU debugger, vagy GDB,
amely lehetővé teszi számunkra, hogy vizsgálja meg a belső működését a program sokkal
részletesen.
>> Mi lehet ténylegesen végre GDB parancssorból
Itt egyszerűen írja GDB és a parancsot, hogy azt akarjuk, hogy debug.
Ebben az esetben, számítanak.
Most ebben az esetben azt látjuk, hogy ez elérkeztünk ahhoz a prompt, amely azt mondja GDB.
És mi is valójában parancsok végrehajtására a GDB
indulhatott végrehajtása programot, hagyd abba bizonyos pontokon,
értékeli a változók és vizsgáljuk meg a változók
létezik a programban állam abban a pillanatban,
és így tovább, és így tovább.
Ez egy csomó energiát számunkra.
>> De ez csak azért történik hogy a CS50 IDE is
egy GUI vagy a felhasználó Akadálymentes GDB, hogy
lehetővé teszi számunkra, hogy ezt anélkül, A parancssori felület egyáltalán
vagy egyáltalán még.
Úgy, ahogy én is elérheti, hogy ez a debug gombot
legtetején a CS50 IDE.
Most a múltban, mi van láttam, hogy mi használja a parancsot
vonal összeállításához majd futtatni a programot.
>> A debug gomb működik mind a két lépést.
De ez is felhozza a debugger fület a szélsőjobb
amely lehetővé teszi számunkra, hogy vizsgálja meg a különböző tulajdonságok a program
mivel fut.
Ha rákattintok hibakeresés, ebben a esetében, ez hozza létre
Új lap a konzol ablak legalján.
>> És akkor láthatjuk, hogy ez a lap van Egyes információk legtetején.
És mi is nagyrészt figyelmen kívül hagyják ezt.
De az egyik dolog, hogy szeretnénk észre
az, hogy kiadja ugyanaz a dolog, hogy mi
kapnánk, ha megpróbált elfutni, hogy a A C program a terminál ablakban.
>> Itt látjuk, hogy fut csengés, és ez már számos zászlók,
és ez összeállítása a count.c fájlt, amely a kijelölt lap idején
hogy megütöttem a debug.
Tehát ez nagyon hasznos, mert Most ezzel a hibakeresés gombot,
tudunk egyszerre lefordítani, majd A program futtatásához, hogy valójában
szeretné futtatni.
>> Az egyik a zászlókat, hogy fontos, ebben az esetben,
mi már valóban használ a leghosszabb ideig
hanem csak volt néhány kéz hullámzó [hallható], amely
ez az egyik itt.
Ebben csengés, azt mondja -ggdb3.
Ebben az esetben, mi vagyunk mondja csengés, a fordító,
az, hogy akarjuk lefordítani a programot.
Hanem biztosítja mik nevezett szimbólum információk
úgy, hogy a fordítóprogram valójában hozzáférés hogy sok a mögöttes információk
tartalmazta a programon belül.
>> Pontosabban, a szám A funkciók, hogy én,
a nevét, e funkciók, A változók típusai
hogy az említett változók, és a különféle Más dolog, hogy segítse a debugger
végre annak működését.
Most van itt még valami ez fontos megemlíteni
amikor mi beszélünk működési egy programot ezen a módon.
>> Figyeljük meg, hogy az valóban hozta létre egy új lapot a mi konzol
alján.
Már nem kell, hogy befolyásolja közvetlenül a terminál ablakot.
De ez az új lap valójában egy terminál ablakot.
Csak kifejezetten a működési programot hoztunk létre.
>> Figyeljük meg, hogy az alján, a kombinálva valamilyen kimenetet
által csenget a fordító és a GDB, amit nagyrészt figyelmen kívül hagyni,
ez tulajdonképpen a kimenetét Programunk legalján.
Most fontos, hogy észre hogy ez az egyik ablakot ténylegesen
megmutatja a kimenet a programból
hanem tudja fogadni input az adott programhoz is.
>> Tehát közleményben, amely szerint Kérem adjon meg egy számot,
amely ugyanaz kimenet, hogy mi volt volt a terminál ablakban előtt.
De ez most bemutatott új lapon.
Én számot adhat.
És ez valóban funkciót, s reményeink szerint
megmutatja nekünk a hibakeresés, teljesítmény, A kimeneti hogy lehet hibás,
mint láttuk korábban.
És legalul, hogy valóban van néhány további kimeneti
a GDP-ből csak azt mondom, hogy ez a program befejeződött.
>> Most, ahogy meglátta ebben a Különösen végigmenni,
ez nem volt különösebben hasznos, mert még
Bár mi volt a debugger menü jön fel, ez még mindig egy futó program.
Egyszer sem volt, hogy valójában szünet végrehajtás nekünk
hogy képes legyen Ellenőrizzük valamennyi A változók tartalmazott.
Van még valami más hogy meg kell tennünk annak érdekében,
hogy GDB felismerni, hogy szeretnénk szüneteltetheti a program végrehajtása
és nem csak lehetővé teszi, hogy folytassa általában ahogy azt bármely más esetben.
>> Annak érdekében, hogy szünet végrehajtását, néhány különleges vonal,
létre kell hoznunk mi úgynevezett töréspontot.
És egy töréspontot nagyon könnyen létre Ebben CS50 IDE azáltal, hogy az egér
és rákattint közvetlenül balra Néhány egyedi sorszámot.
Egyszer én, hogy egy piros pont jelenik meg, amely azt jelzi,
hogy ez a vonal ma egy töréspontot.
>> És a következő alkalommal, hogy futok GDB, hogy leáll végrehajtást hogy töréspontot
amikor eléri, hogy a kódsort.
Most ez egy fontos dolog, hogy észre
hogy ez nem feltétlenül a Amennyiben minden kódsort
valójában kérhető.
Ha én is olyan függvényt akár itt, example-- void F--
és csak a nyomtatási sor here-- helló world-- ha soha többé nem hívja ezt a funkciót,
ez lesz a helyzet, hogy, Ha én meg egy töréspontot itt,
A funkció nem nevezhető.
És ezért ez a Különösen töréspontot
soha nem fog ténylegesen szünet a program végrehajtását.
>> Mondjuk, hogy én helyesen létre töréspontot néhány kódsor
hogy valóban végre kell hajtani.
Most ebben az esetben, ez a első sorban a fő funkciója.
Szóval akkor minden bizonnyal a helyzet hogy amint elkezdem végrehajtását,
Az első sorban fognak elérni.
GDB szünetelteti végrehajtását.
És akkor én képes lesz kölcsönhatásba a debugger.
>> Beállíthatjuk, több vonal, mint töréspontok, ha szeretné.
Mi is létrehozhat egy sorban Itt ebben a szegmensben a kódot
hogy soha nem fog elérni.
És mi is meg egyet alább.
Az ok, hogy mi lenne akarom ezt fogunk
bemegy egy kicsit részletesen csak egy pillanatra.
Tehát most, hadd tiltsa E további töréspontok
hogy tudjuk meg, mi történik amikor már egyetlen szünet
pont a programot.
Tettem néhány változások ezt a programot.
Szóval kell menteni.
Én kattintson hibakeresés, így én is elkezdjük a fordítási majd
végrehajtása a debugger.
>> Látni fogjuk, hogy miután pillanatok, a vonal, amit választott, mint a szünet
pont sárga színnel.
Azt is észre, hogy a jobb felső a hibakeresés panel
hogy a szünet ikonra vált egy kicsit játszani ikonra.
Ez azt jelenti, hogy van szünet végrehajtás, ebben a konkrét esetben.
És üti meg a Play gombot is lehetővé teszi számunkra, hogy folytatódik a végrehajtás
ezen a bizonyos pontot.
>> Figyeljük meg, hogy van egy pár más gombok áll rendelkezésre ebben a hibakeresés panel,
is.
Átlépni, amely lehetővé teszi számomra, hogy végre, hogy egy sor kód
és átlépni a vonalat, hogy a következő, amely ebben az esetben,
azt jelentené, hogy a printf utasítás végrehajtása.
És akkor majd a szünet végrehajtás on-line 13, valahogy így.
>> És van még egy lépéssel a funkció, amely
akkor hasznos, ha azt korábban már létrehozott funkciók máshol a forráskódot.
És azt akarom, hogy belépjünk azok a funkciók helyett
végre, hogy a funkció egészére.
De akkor nézd meg többet a lépést a funkció csak egy pillanatra.
Most észre néhány más dolog, hogy valóban létezik ezen belül a debug panel.
>> Van ez a testület az úgynevezett hívja verem, amely megmutatja nekünk
hogy pontosan hol vagyunk.
Ebben az esetben, mi belsejében a fő funkció.
A szkript indul count.c.
És mi történik, hogy a 13. sor, oszlop egy, ami
Pontosan ez a kiemelt terület A forráskód jelzi is.
>> Most észre, hogy ez is azt mutatja, alatt helyi változó szakasza
az összes változók léteznek ezt a funkciót.
Fontos megjegyezni, hogy az összes változók
akkor jelenik meg a helyi változó szakaszban egy függvényen belül,
még mielőtt azok meghatározása.
Láthatjuk, hogy itt van egy változót nevű num, van egy alapértelmezett értéke 0,
és ez a típus int.
>> Most, mielőtt ténylegesen alaphelyzetbe az összes ilyen változó,
nem vagyunk feltétlenül garantált, hogy a 0 érték.
És attól függően, hogy a többi kivégzések hogy van végre
és az állam a memóriát, ha ha valóban futtatni ezt a programot,
lehet találni, hogy Nem látom értékek 0
és ahelyett, néhány más őrült számokat.
>> De ne aggódj.
Ez nem lesz releváns, amíg hogy tényleg inicializálni az értéket.
Most ebben az esetben azt látjuk, hogy Elvégeztem néhány kimenet.
És én, most, megállt végrehajtását.
De ebben az esetben, mi Nagyon szeretnék csinálni
az, hogy most már átlépni ezen a vonalon kódot, így tudok ténylegesen
lekérdezheti a felhasználó számára, hogy int, hogy akarjuk használni a programban.
>> Most ebben az esetben, amikor Elütöttem átlépni, értesítés
hogy a Szünet vagy inkább a Folytatás gombot változott ez a szünet gomb
mivel ez a kód valójában a végrehajtó.
Mi történik most az, hogy ez
vár ránk, hogy be némi információt mint látjuk a mi kimeneti szöveges
legalján.
>> Tehát most, ez valójában nem szünetel,
még akkor is, egyfajta, úgy tűnik, hogy azért, mert nem történik semmi.
De ez csak azért történik, hogy a én különleges eset a 13. sor,
Várom a felhasználótól.
És így GDB nem tudunk ellenőrizni a program fut.
>> Most a következő alkalommal, hogy én meg néhány input-- úgyhogy be, hogy az 5-ös,
mint láttuk, a past-- Return, és mi
észre, hogy azonnal, GDB szünetek és ismét rávilágít a következő sorban.
De észre, hogy most, mint egy eredményeként a bevitele egy értéket,
frissítettük, hogy értéket belülről A helyi változók, amelyek
Nagyon hasznos, hogy pontosan tudja, mi ez a szám a memóriában.
>> Most már tudom hogy ez a program, hogy továbbra is játszik végéig annak végrehajtását
ütő Folytatás.
Láthatjuk, hogy nagyon gyorsan működik a program célba végrehajtó
ugyanekkora kapacitású hogy korábban, a debugger bezárja,
és most ezt a programot teljesen leállt.
>> Azt mutatják, hogy csak a alkalmazásában látta, milyen
történik, amikor nekiütközött Folytatás.
De mi valójában fognak vissza akarok menni ebbe a programba
hogy mi lehet próbálni a hibakeresés Pontosan mi történik.
Most, hogy én vagyok a hibakereső, én is Nem kell ezeket a hibakereső printf kifejezést.
>> Így tudtam eltávolítani őket fogom csinálni Most csak azért, hogy visszatérjünk az egyszerűbb kódot
hogy mi volt az imént.
Most, amikor menteni a programot, és indítsa meg,
Majd ismét, megy, hogy a kezdeti töréspontot, hogy volt a 11 sor.
És én leszek képes ellenőrizni én változókat akarok csinálni.
>> Ez csak azért történik, hogy ez a része nem túl érdekes,
És tudom, hogy fogok kinyomtatni ezt a kijelentést.
Kérem adjon meg egy számot.
És akkor, tudom, hogy fogok megkéri a felhasználót, hogy az egész.
Így talán, én valóban akarjuk mozgatni az én töréspontot egy kicsit lejjebb.
>> Akkor távolítsa töréspontok kattintva, újra, közvetlenül
balra, hogy a vonal számát.
Hogy piros pont eltűnik, jelezve, hogy ez a töréspont most elment.
Most ebben az esetben, végrehajtás lett állítva.
És így nem ténylegesen fog folytathatja az adott esetben.
De azt lehet állítani egy kis szünetet pont egy kicsit később.
>> És ha most folytatom a kódot, akkor folytatódik, és mondd
a lényeg az, hogy töréspontot.
Ismét elütöttem Folytatás.
Nem úgy tűnik, mint bármi történik.
De ez, mert a kód bemenetre vár.
Én meg egy 5-ös szám, az Enter leütése, és most a következő töréspontot fogja sújtani.
>> Most ebben az esetben, ez a a kódsort
hogy mielőtt tudtuk, történetesen hibás.
Szóval értékelik, hogy mi történik különösen ebben az időpontban.
Ha egy sor ki van jelölve, vonal még nem hajtották végre.
Tehát ebben az esetben, azt látjuk, hogy van egy szám, amely
Van egy egész úgynevezett num, aminek értéke 5.
És fogok is fellép Egyes matek azt a számot.
>> Ha én átlépni, hogy tudjuk észre, hogy az érték a num
megváltozott összhangban aritmetikai, hogy mi már kész.
És most, hogy mi vagyunk belsejében ez a hurok
vagy most, hogy a for ciklus Maga ki van jelölve,
azt látjuk, hogy van egy új nevű változó i, hogy
lesz használni, hogy hurok.
>> Most emlékszem előtt, hogy én Említette, hogy néha te
fog látni valami őrült szám alapértelmezett előtt ez a szám
vagy azt, hogy a változó ténylegesen inicializálni.
Láthatjuk, hogy pontosan Itt az e változó
úgynevezett I, amely nem Még inicializálták
idején kiemelve.
De látjuk, hogy vannak száma hogy valójában nem számítanak.
>> Rendben.
Ne aggódj emiatt mert van valójában nem
inicializált azt a számot, amíg én átlépni ezt a sort, és az értéke
Én már kezdeti értéke az 1-es érték.
Tehát látni, hogy ez ténylegesen az ügy, nézzük átlépni.
Most már látjuk, hogy ez a tétel került végrehajtásra.
És most kiemelve ez a printf sor.
>> És most már látom, hogy az értékeink az i és 3 változott az idők során.
Ez nagyon hasznos, hogy nem, sőt, van átlépni vonalak többször.
És megtalálja, amit ténylegesen belsejében történik a hurok
és mi történik a változók belsejét, hogy a hurok
mint hogy a program végrehajtása bekövetkezik egy lépéssel egy időben.
>> Most ezen a ponton, azt átlépett éppen elég
hogy én most vagyok a végén én programom.
Ha én átlépni, hogy ez lesz ténylegesen megszűnik végrehajtása
mint láttuk a múltban.
Hadd újraindítani ezt, de újra, így hogy én is pont valami mást,
is.
>> Ebben az esetben, ez Most azt kérdezik tőlem, újra,
egy szám, amely Én ismét be.
De ezúttal fogok bemenni nagyobb számú, hogy a for ciklus
majd hajtogat több alkalommal.
Ebben az esetben, megyek hogy adjon meg egy értéket a 11.
>> Most újra, mert azt állítva egy töréspontot a sorban 15,
ez lesz kiemelni, hogy a vonal.
Láthatjuk, hogy a 11-es szám helyesen
képviselteti magát a helyi változókat.
Odalépett, hogy most már nézd, mi történik a mi i értéke
ahogy haladunk belül ez a for ciklus.
Egyre növekszik minden alkalommal, amikor éri el a tetején, hogy a hurok.
>> Most az egyik dolog, ami talán hasznos lehet csinálni a végrehajtás során
Ennek a programnak az a számomra, hogy ténylegesen módosítsa a változók midstream látni
mi történik az én programot.
Ebben az esetben én valóban kattintson duplán az értéket.
Figyeljük meg, hogy ez lesz a szövegmezőbe.
>> Most már be különböző értékeljük összesen
hogy milyen a program viselkedésére ha én változtam, hogy változó.
Most, ebben az esetben a változó Én most már tartalmazza a 10-es értéket.
De a program még mindig Megállt végrehajtását.
Amikor átlépni, látom, hogy a értéke i, amelyek beléptem a 10,
nem nagyobb, mint az érték a num, ami azonnal okoz a hurok
megállítani végrehajtó.
>> Most, hogy nem ez az egyetlen ok, hogy miért lenne
módosítani akarja a változó helyére.
Lehet, hogy tényleg akar hogy megpróbálja módosítani úgy,
hogy tovább folytathassa végrehajtása a hurok
vagy úgy, hogy lehet módosítani néhány érték, mielőtt
elér valamilyen konkrét aritmetikai hogy hamarosan végezni.
>> Tehát most, hogy valóban változtatni a i értéke, mint a program végrehajtása,
ez okozta a for ciklus leszokni miatt idő előtt, hirtelen, i
történt, hogy nagyobb, mint az értéke A szám, ami azt jelenti, hogy ez a hurok
A már nem szükséges, hogy végre kell hajtani.
Továbbá úgy történt, hogy a esetben, hogy mi változott az i értéke
ha a 17. sorban is kiemelte, amely az időpontban
hogy az a ciklus végrehajtása ténylegesen értékelni.
>> Ha tudtam volna változtatni az értékét Én egy másik vonalon, mondjuk 19,
láttuk volna más viselkedés, mert a 19 lenne
végrehajtotta a ciklus előtt feltétel átértékelődött.
Most ezen a ponton vagyok, megint, végén ezt a programot.
És azt is lehetővé teszi, hogy folytassa ezt a lehetővé teszi a programot, hogy kilép a természetben.
De van egy pár dolog amelyek fontosak, hogy elvegye
ez alól vitát.
Be kell, hogy értékelje a saját feltételezések
arról, hogy a kódot kell viselkedik.
Minden alkalommal, amikor úgy gondolja, hogy néhány darab A kódot tudod történik dolgozni,
hogy lehet egy piros zászló menni vissza, és értékelje, és győződjön meg róla,
hogy a feltételezése hogyan kód működik
valóban igaz, hogy így van kifejezve a forráskódot.
>> De még a pont az volt, amikor mi használ a debugger,
akkor tegye meg töréspontok különböző sornyi kódot,
aminek hatására a hibakereső szüneteltetheti végrehajtás minden ilyen vonal
így értékeli a memória vagy meg is változtatja a helyére.
És ismét, ne feledje, hogy tudsz hozzon létre több töréspont, így
is folytatódik a végrehajtás, hagyja mint nagy része kódot,
és akkor automatikusan szünet A következő töréspontot.
>> Itt tulajdonképpen fejlettebb jellemzői a debugger is.
De mi lesz, hogy utalja be Egyes utólagos videók
annak érdekében, hogy valóban ugratni egymástól, hogyan hogy az említett bizonyos funkciók.
Most, köszönöm Nagyon sokat nézi.
És sok szerencsét a hibakeresés.