Hallo en welkom terug.
In deze lezing wil ik een demonstratie geven van het gebruik van de debugger.
Ik wil dus de grafische gebruikersinterface doorlopen en laten zien hoe je een programma kunt starten in debugmodus,
hoe je breakpoints kunt instellen, hoe je naar de call stack kunt kijken en hoe je verschillende variabelen kunt bekijken
met het watch window.
Gewoon een simpel programma dat een gemiddelde bepaalt.
Ik ga dit gebruiken als mijn demonstratie.
Het leest alleen drie gehele getallen in, slaat ze op en berekent dan hun gemiddelde.
Voordat we de debugger gaan gebruiken, moet je ervoor zorgen dat je configuratie
correct is ingesteld.
En ik heb hierover gesproken in een eerdere video, in principe het configureren van code light voor het gebruik van de debugger.
Maar om je geheugen op te frissen, je kunt het project hier selecteren, je kunt rechts klikken en naar instellingen
gaan.
Je moet er opnieuw voor zorgen, afhankelijk van het platform waarop je zit, dat de debugger-instellingen
hier links het juiste pad naar GDB hebben.
Als u op Windows zit, kan dat betekenen dat u GDB X van Cygwin gebruikt of dat u de MinGW w64 gebruikt, wat u ook aan de praat
krijgt.
Bij Unix en Linux hoeft dit pad niet eens per se ingesteld te worden.
Het andere belangrijke is dat je in de compileropties ervoor wilt zorgen dat je compileert
voor debuggen, zodat Dash G dwarf op dash o staat voor optimalisatie.
Nogmaals, in Windows moeten die dingen worden ingesteld om foutopsporingsinformatie bij uw uitvoerbaar bestand
te krijgen.
Je moet er ook voor zorgen dat je bouwt voor debug modus.
Dus je moet ervoor zorgen dat debug is geselecteerd en niet release.
Als je al die dingen goed hebt ingesteld, zou je de debugger en code light moeten kunnen gebruiken.
Als je daar problemen mee hebt, ga dan terug naar mijn video voor het configureren op jouw platform.
De Debugger en Code Light.
Het belangrijkste concept met betrekking tot de debugger is het idee van een breakpoint.
En dus is een breekpunt iets dat je in je programma kunt instellen om de uitvoering van je code te
stoppen.
Je kunt in wezen zeggen, Hé, ik wil stoppen bij deze regel en je programma zal, wanneer je de debugger
uitvoert, stoppen bij die regel. Zo kun je kijken naar variabelen, de waarden van variabelen.
Hiermee kunt u uw code regel voor regel doorlopen om te proberen een diagnose te stellen en eventuele problemen
op te lossen.
Normaal gesproken, als je je programma probeert uit te voeren in de debugger en je hebt geen breekpunt ingesteld,
zal er niets gebeuren.
Dus normaal als je bouwt, weet je, kun je gaan en je kunt je project bouwen net als
elk ander project, ga naar bouwen, ga naar project bouwen.
Wanneer je het bouwt en uitvoert in debug modus, moet je naar de debugger menu optie gaan en
naar start, doorgaan met debugger.
En als je dat opnieuw uitvoert, als je een breekpunt hebt ingesteld, zal het dat raken.
Als je geen breekpunt hebt ingesteld, loopt het gewoon door.
Dus als we dit programma proberen uit te voeren in debug modus, komt het gewoon tevoorschijn en vraagt
om enter omdat het stopt bij de getallen en dan sla je wat getallen in en het sluit gewoon af.
Het drukt de informatie niet eens af, toch?
Het is dus heel belangrijk dat u, als u de debugger wilt gebruiken, ten minste één breekpunt hebt ingesteld.
De eenvoudigste manier om een onderbrekingspunt in te stellen is door simpelweg binnen de marge bij de regelnummers te klikken op het regelnummer waarop u het onderbrekingspunt
wilt instellen.
En nogmaals, een breekpunt stopt de uitvoering op dat regelnummer.
Dus als we een breekpunt instellen bij de printf-functie op regel tien, dubbelklikken we gewoon, dan zie je dat
er een rode cirkel wordt geplaatst.
Dit vertelt de debugger, hé, stop bij regel tien.
Dus nogmaals, de manier waarop we de debugger starten is we gaan naar debugger en we zeggen, start, doorgaan,
toch?
Al het andere is een beetje grijs, toch?
Dus laten we de debugger starten om dat breekpunt te bereiken.
Dus laten we beginnen met de debugger en we zeggen bouwen en debuggen en je zult zien
dat het programma stopt bij regel tien.
Je ziet die groene pijl, Je ziet ook dat het debugger scherm tevoorschijn komt.
Dus als u naar weergave gaat, kunt u het debuggerpaneel handmatig oproepen of het kan automatisch opkomen
als u naar de debugmodus gaat, en het debuggerpaneel heeft veel verschillende tabbladen voor informatie die kan worden bekeken.
Je kunt er ook doorheen gaan via de debugger, als je naar GDB vensters gaat, kun je alle aangevinkte
vensters zien.
Er zijn veel debugger-vensters die je kunt bekijken.
Dus locals heeft meestal te maken met je lokale variabelen horloges.
Je kunt een horloge op een variabele zetten, zodat als de variabele verandert, deze verschijnt.
Output is te gebruiken voor verschillende debug-opties en output threads.
Je kunt echt kijken naar de threads die je programma draaien.
Meer geavanceerd concept Callstack is waar we ons op richten.
We kijken in principe naar de call stack en de locals.
Dat zijn de twee belangrijkste die je helpen bij het debuggen en dan geheugen en dan ook nog breakpoints.
U kunt zien waar de breekpunten zijn ingesteld.
Dus veel verschillende opties.
We zijn momenteel gestopt bij lijn tien.
We kunnen naar de oproepstapel kijken.
De aanroepstapel toont ons dat de hoofdfunctie wordt aangeroepen.
Als we naar locals kijken, zien we drie variabelen nul een en nul.
We hebben eigenlijk geen informatie ingevoerd in die zijn geïnitialiseerd nul een en nul.
Het horloge is dat je daadwerkelijk kunt toevoegen.
Toevoegen door op het plusteken te drukken om een horloge op een bepaalde variabele toe te voegen.
En dan het andere belangrijke ding om op te merken is als je in debug modus draait, heb je nu de
werkbalk voor de debugger, toch?
De afspeelknop gaat gewoon door.
Zo zal het gaan.
Als ik op play druk, sluit het programma toch gewoon af?
Het begint gewoon te lopen.
Het programma vraagt eigenlijk om invoer.
Dus drukte ik op play.
Ik ga terug naar de console applicatie en het zegt Enter.
Dus ik raakte mijn drie nummers in het programma loopt.
Dan heb je nog steeds de afdrukfunctie niet gezien.
Het raam ging gewoon weg.
Dus nogmaals, we draaien in debug modus en het gaat weer naar het breekpunt, het debugger venster verschijnt, het stopt
regel tien.
De werkbalk is belangrijk omdat je zo door je code kunt stappen en je kunt
de werkbalk gebruiken of naar de debugger gaan en alle opties hier bekijken.
Dus je kunt zeggen stap in stap in instructie volgende, volgende instructie, stap uit, stap in gaat binnen
een functie.
Als op die regel een functie wordt aangeroepen, gaat de stap-in-instructie meer naar de assembleertaal.
Vervolgens springen we over die regel code heen.
En nek instructies zijn ongeveer hetzelfde.
Stap uit, probeert uit een functie te springen als je er al in zit en springt naar de wortellijn.
Eigenlijk denk ik dat het naar de cursor gaat.
Hetzelfde met rennen naar de wortellijn.
U kunt onderbrekingspunten in- en uitschakelen, ze allemaal uitschakelen, al die dingen zodat u dit via het menu kunt
bereiken.
Of nogmaals, de werkbalk.
Meestal gebruik ik de werkbalk omdat die er al is.
En als je dan weer kijkt naar de verschillende vensters, locals call stack en breakpoints.
Echt die belangrijke.
Dit zegt dat ik een breekpunt heb op regel tien.
En dan denk ik dat men gewoon de cursor zegt.
Dus nu ben ik gestopt bij print F enter op regel tien.
Ik kan naar de volgende instructie gaan en deze zal naar regel 11 scannen.
F is eigenlijk een blokkeringsfunctie die om invoer vraagt.
Dus als ik probeer naar de volgende stap te gaan, pauzeert hij.
Je moet misschien meerdere keren op next drukken.
Wat ik meestal doe als het programma om input vraagt en ik wil het, het is al geblokkeerd, het is al gestopt en ik
wil dat het naar het volgende gaat.
Ik zet een breekpunt op de volgende regel en druk op de afspeelknop.
Dus nu druk ik op de afspeelknop en er gebeurt niets omdat het wacht op invoer.
In het programma staat Enter.
Dus hier kan ik op vijf, zes, zeven drukken, de enter knop indrukken en nu raakt het mijn breekpunt.
Dus nu zijn we bij de afdrukknop waar we naar de afdrukfunctie kunnen gaan.
En eigenlijk springt hij eerst naar de gemiddelde functie.
Dus als we zeggen stap in zien we dat we naar de gemiddelde functie gaan.
En als je naar je variabelen kijkt, zie je ze veranderen.
Dus als je volgende gaat, ga je naar de volgende regel in 27, dan 28, en dan blijf je slaan.
Vervolgens spring je eruit en ben je eigenlijk aan het einde van de functie.
Dus dan kun je op play drukken en zie je dat je programma nu is voltooid en dat het venster is verdwenen.
Maar je kunt naar je variabelen kijken, je kunt naar al het andere kijken.
En dus, nogmaals, kun je ook een breekpunt plaatsen in de afdrukfunctie hier.
En als we die uitvoeren, zien we weer dat de afdrukfunctie de uitvoering stopt in plaats van het gemiddelde.
En dan kunnen we zien wat er in de praktijk gebeurt als we naar de toepassing
gaan, en zien dat de informatie is uitgeprint.
Toch?
Als je doorgaat, als je naar het einde loopt, krijg je het return statement en sluit het programma af.
Het is dus belangrijk dat als je de uitvoer van het programma wilt zien, dat je een breekpunt
plaatst vóór die terugkeer en dat je niet hoeft door te gaan.
U kunt de debugger stoppen door op die rode rechthoek te drukken, de debugger pauzeren door op de twee parallelle
balken te drukken, de debugger opnieuw starten met die optie en de callstack.
Nogmaals, het is makkelijker te zien als je in een functie komt en de debugger draait, we draaien de debugger
opnieuw.
Zeg debugger, start, ga verder.
En wanneer we dat breekpunt raken na het invoeren van informatie in een functie, zul je zien dat de autostapel
de main en de print heeft, zoals we eerder lieten zien.
En dus zie je de laatste functie die werd aangeroepen, nu met een programma dat veel functies enzovoort heeft,
kan de aanroepstapel veel groter worden dan dit.
Het enige andere dat van belang kan zijn, zijn de breekpunten.
Als u wilt zien welke breekpunten u hebt ingesteld, toont het u alle breekpunten en uw hele programma waar
ze zich bevinden.
Maar u zult hiermee moeten spelen, er vertrouwd mee raken en het vrij vaak gebruiken voor problemen die
u niet kunt oplossen met eenvoudige debuggingtechnieken of -programma's.
Crash gaat regel voor regel.
En als u regel voor regel doorloopt, kunt u het programma zien afbreken zodra het vastloopt
en weet u op welke regel dat gebeurde.
Nogmaals, dit is een klein programma, maar je zou de basis moeten begrijpen van hoe debuggen werkt.
Nogmaals, ik hoop dat dit nuttig was.
De beste manier om dit spul te leren is ermee te gaan spelen en het te gaan gebruiken.
Breng één van de programma's naar boven waaraan je in je vorige uitdaging hebt gewerkt.
Voeg een breekpunt toe, heel eenvoudig.
Klik gewoon rechts in het ding om breekpunten toe te voegen.
Start het op in debug modus en stap door elke regel en zie hoe de variabelen veranderen en hoe de aanroepstapel
toeneemt.
Als je grotere functies hebt.
Bedankt.