Stoppa vid och återuppta från en brytpunkt - dummies

Att lära sig att använda debugger är en av de viktigaste sakerna du kan göra för att uppnå ditt C ++-spel. Följande steg är nödvändiga för att ställa in en brytpunkt, stoppa programmet, granska några variabler och fortsätta programmet.

Från och med våren 2014, Kod:: Blokker integreras inte med debuggeren för Mac, så om du är en Mac-användare kanske dessa exempel inte fungerar för dig.

Vad är en debugger?

Innan du går längre kan det hjälpa om du förstår vad en debugger är. En debugger är ett separat program som låter dig styra ditt exekveringsprogram. Specifikt låter du stoppa körning av programmet på specifika linjer kod, för att undersöka värdet av variabler, ändra värdet av variabler och återuppta genomförandet av programmet.

GNU debugger har ett kommandoradsgränssnitt som är både svårt att komma ihåg och svårt att använda (det är en vinnande kombination om du någonsin hört en). Lyckligtvis Code:: Blocks ger ett nästan sömlöst grafiskt gränssnitt till GNU debugger. Medan du klickar på redigeringsfönstren och aktiverar rullgardinsmenyerna, Code:: Blocks skickar kryptiska kommandon till debugger i bakgrunden och tolkar och visar grafiskt resultaten. Är det inte bra när två program chit-chatt i bakgrunden för att rädda dig?

Det bästa sättet att lära sig om debugger är att bara följa dessa exempel.

Installera ditt program för att använda debuggeren

Du måste bygga ditt program med hjälp av speciella kompilatorinställningar om du tänker köra den under kontroll av debuggeren. Det enklaste sättet att göra detta är rätt i början när du skapar ditt projekt. När du har angett att du vill skapa en konsolansökan och tillhandahåller programmets namn, Kod:: Block kommer att fråga dig om du vill bygga ditt program i Debug-konfiguration, Släpp konfiguration eller båda, som visas i Figur 1. Var säker på att Debug-konfiguration är aktiverad.

Figur 1: Projektguiden ger dig möjlighet att ange en Debug-konfiguration när du skapar projektet.

Ett program i Debug-konfiguration innehåller mycket extra information som debuggeren behöver för att kunna göra sin magi. Denna information innehåller

• Adressen till varje rad av C ++-källkod

• Adressen till varje variabel

• Namnen och sminken i varje klass i ditt program

All denna debuggerinformation lägger mycket massa till det körbara programmet - hundratals kilobytes eller mer. Detta utrymme är helt onödigt om du inte avser att köra programmet under kontroll av debuggeren, så Kod:: Block ger dig möjlighet att bygga körbara filer utan den här informationen i så kallad Release-konfiguration.Släppprogrammen är mindre, laddas snabbare och till och med körs snabbare.

Om du aktiverar både Debug and Release-konfigurationer i ditt projekt kommer du att välja att välja vilken typ av körbar du vill bygga.

Det finns två skillnader mellan Debug and Release-konfigurationer:

• Debug-konfigurationen innehåller kompileringsalternativet -g .

  Det här alternativet säger att kompilatorn ska inkludera symbolinformation i den slutliga körningen. Det här är allt som nämns ovan - adressen till varje kodlinje och varje variabel, samt en beskrivning av varje klass som används i ditt program.

• Kodoptimeraren är avstängd i Debug-konfiguration och påslagen i Release-konfigurationen.

  GNU-kodoptimeraren genererar program som körs snabbare, men det gör det genom att flytta instruktioner på sätt som kan vara ganska förvirrande när du felsöker ditt program. Utlösningskonfigurationen innehåller inte -g -knappen och möjliggör viss nivå av optimering genom att -O kopplas in.

Se till att du för närvarande bygger Debug-utgåvan genom att välja Bygg → Välj mål → Felsökning, som visas i Figur 2.

Figur 2: Du måste fortfarande se till att du bygger den debuggable körbara, jämn om du aktiverade Debug Configuration när du skapade ditt projekt.

Uppgradera ditt program genom att välja Bygg → Återuppbygga.

Stopp vid en brytpunkt

För att ställa in en brytpunkt, klicka bara på området precis till höger om radenummeret - detta område är känt i Kod:: Blinkar parlansen som tråget. Inte bara visas linjen i en annan färg, vilket indikerar att redaktören har markerat den, men ett litet stoptecken visas i tråget, som visas i Figur 3. Detta är en indikation på att en brytpunkt har ställts in på rad 11.

Figur 3: Kod:: Block använder en söt liten stoppskylt för att indikera när en brytpunkt är inställd.

Du kan ställa in så många brytpunkter som du vill på en gång, men den här brytpunkten kommer att vara bra för det här exemplet.

Här kan du starta programmet med hjälp av alternativet Debug → Start / Continue som visas i Figur 4.

Figur 4: Starta (eller återuppta) exekveringen av ditt program med menyn Debug-> Start / Continue.

Programmet börjar exekvering som normalt men stoppar nästan omedelbart med en liten gul pil som pekar på linje 11 som visas i figur 5. Dessutom visas ett tomt fönster som normalt innehåller programutmatning. Ingenting visas i programutmatningen eftersom rad 11 ännu inte ska utföras.

Figur 5: Programutförandet stannar så snart programmet möter en brytpunkt.

Wow! Det är coolt.

Återuppta körning av ett program

Du kan ställa in en brytpunkt på nästa rad och välja Debug → Start / Fortsätt för att fortsätta att exekvera programmet till nästa rad om du vill. Men eftersom det här är så vanligt att göra, Code:: Blocks ger alternativet Debug → Next Line, vilket betyder "Kör programmet till nästa rad."

Detta gör att programmet snabbt blinkar, eftersom kontrollen övergår till programmet, tillräckligt länge för att utföra linje 11 innan det kommer till ett stopp igen, som visas i Figur 6.

Figur 6: Genomför kommandot nästa kommando orsakar debuggeren för att utföra en rad i programmet.

Du kan upprepa denna process så ofta som du vill, och kan enkelt stegvis gå igenom programmet.

När du kommer till ett funktionssamtal, fortsätter nästa linje i den aktuella funktionen, kör hela funktionen som om den bara var en enda linje (vilken är den på den här nivån). Om du vill skicka kontroll till funktionssamtalet väljer du Debug → Step Into istället. Detta fungerar bara för funktioner som du har källkoden för - det fungerar inte bra för C ++-biblioteksfunktioner.

Varje gång du blir trött på att gå in, kan du avsluta programmet genom att välja Debug → Stop Debugger. Det stoppar inte bara debuggeren, det stoppar också ditt program.

Undersök variabler

Ensteg genom ditt program är ett bra sätt att få en känsla för var ditt program går, men det kan vara svårt att förstå varför, om du inte kan undersöka variablerna som används för att fatta beslut. När du till exempel gör ett enda steg i exemplet programmet kanske du märker att kontroll inte alls går in i för -slussen. Varför är det så?

Du stoppar programmet genom att välja Debug → Stop Debugger eller trycka på Shift + F8 och starta om genom att välja Debug → Start / Fortsätt eller tryck på F8. Enkelt steg genom att välja Debug → Next Line eller trycka på F7 tills exekveringen når början av för -slingan.

Se till att fönstret Watch är synligt genom att välja Debug → Debugging windows → Watches. Ett fönster som det i Figur 7 visas och visar värdena på argumenten och eventuella lokala variabler. Observera att nNumberofArgs är 1, bara namnet på själva programmet. Eftersom jag börjar med ett värde på 1, kommer slingan aldrig att utföras. Lägg till klockvariablerna pszArgs [0] och pszArgs [1] för att se vad de innehåller: programmets namn och en null. A ha! Programmet har inga argument att iterera över.

Figur 7: Fönstret Watch gör att programmeraren kan visa värdet av variabler.

Du kan ändra argumenten till programmet genom att välja Project → Set Programs 'Arguments. I det här fönstret kan du lägga vad du vill ha.

Observera att fönstret Watch visar mig namnet på variabeln, dess typ och dess värde. Du kan inte ändra dess typ, men du kan ändra dess värde från det här fönstret, om du vill. Att ändra värdet på nNumberofArgs är inte särskilt användbart, men ibland ändrar värdet på en variabel mig att tvinga körning ner en annan väg bara för att se vad som kan hända.

Fortsätter ett stoppat program

Ett knep att komma ihåg är att det ibland kan bli förvirrande om varför ett program stoppas. Inte alla program som stoppas är under kontroll av debugger. Ibland väntar de på inmatning från användaren.

För att se denna effekt, gör du ett steg med programmet PrintArgs tills kontrollen når linje 26.När du väljer Nästa rad, försvinner markören som visas i Figur 8. Borta är den trevliga gula pilen som påminner dig om var du befinner dig i programmet. Vad hände?

Figur 8: Kontrollen verkar gå bort när programmet väntar på användarinmatning.

Vad hände är att programmet väntar på mig att trycka på Enter på tangentbordet. Först måste du välja programfönstret. Då kan du trycka på Enter (du kan behöva göra det mer än en gång). Efter att ha gjort det verkar ingenting hända i programfönstret eftersom kontrollen nu har gått tillbaka till felsökaren i rutan Kod:: Block. När du väljer det här fönstret igen ser du den lugnande gule pilen som berättar för mig den här koden:: Block är tillbaka i kontrollen.

När du kör ditt program under debuggeren och kontrollen tycks gå, kan programmet vänta på inmatning från tangentbordet. Byt till programfönstret för att se om så är fallet. Om så är fallet, så snart du anger något, kommer kontrollen att återgå till felsökaren.