WAP-Pool Mathematik: Fehlersuche (Debuggerbenutzung)

Universität Bayreuth

Mathematisches
Institut

Einleitung

Erste Schritte

Mail und News

Drucken

KDE

LaTeX/TeX

Linksammlung

Linuxtools

Netzwerk

Programmieren

Windows

X Window

Anträge

Kontakt

Programmieren mit Code::Blocks

	I. Start von Code::Blocks II. Projektverwaltung mit Code::Blocks III. Konfiguration von Code::Blocks IV. Debuggen mit Code::Blocks Voraussetzungen zum Debuggen in Code::Blocks Variablenwerte beobachten mit "Watches" Debugger starten/Breakpoints setzen

Debuggen mit Code::Blocks

Code::Blocks unterstützt als IDE auch das Debuggen, also das schrittweise Ablaufen von Executables, das Überprüfen von Variablen zur Laufzeit und das Auffinden von logischen Fehlern in Programmen.

Voraussetzungen zum Debuggen in Code::Blocks

In Code::Blocks kann man C-/C++-Programme nur dann debuggen, wenn das Programm in ein Projekt eingebunden ist. Man muss also zunächst ein Projekt anlegen (vgl. die Projektverwaltung mit Code::Blocks) und das Sourcefile (im Beispiel: "bsp_02.cpp") ins Projekt aufnehmen:

Das C-/C++-Programm muss mit der GCC-Compiler-Option "-g" übersetzt worden sein. Dies ist automatisch der Fall, wenn als Konfiguration "Debug" bei der Projekterstellung angegeben wird.

Variablenwerte beobachten mit "Watches"

Bevor der Debugger gestartet wird, sollte man gleich ein weiteres Fenster öffnen. Im Menü "Debug" kann man unter "Debugging windows" den Punkt "Watches" anwählen:

Das erscheinende Fenster

platziert man am besten unterhalb des Fensters "Management" links neben dem Sourcecode:

Im Fenster "Watches" kann man die Werte der lokalen Variablen unter "Local variables" untersuchen sowie die Funktionsargumente unter "Function Arguments" (jeweils Anklicken auf das graue Dreieck zum Aufklappen des Menüs).

Debugger starten/Breakpoints setzen

Bevor man den Debugger startet, sollte man normalerweise Haltepunkte (breakpoints) setzen, die den Ablauf des Executables (kurzzeitig) anhalten. Ohne Breakpoints läuft das Programm sonst genauso ab wie beim Start des Executables. Das Anhalten des Programmes zur Laufzeit erlaubt es im Debugger, Variablenwerte zu kontrollieren und z.B. den bisherigen Stack der Funktionsaufrufe. Nach dieser Kontrolle kann das Programm (schrittweise) weiterlaufen.

Das Setzen der Breakpoints geht entweder durch das Anklicken in der Höhe des zugehörigen Sourcecodezeile knapp rechts neben der Zeilennummer (noch links von dem Sourcecodebereich) oder durch Anwahl des Punktes "Toggle Breakpoint" im Menü "Debug" (dabei muss der Cursor in der zugehörigen Sourcecodezeile stehen):

Der Breakpoint wird durch einen roten Kreis symbolisiert.

Breakpoints sollte man nicht bei Variablendeklarationen setzen, sondern z.B. am Funktionsanfang (im Beispiel: Zeile 6), um die lokalen Funktionsparameter zu checken oder bei der ersten Anweisung oder Ausgabe (im Beispiel: Zeile 13). Zumeist setzt man auch in der main()-Funktion in der letzten Zeile mit "return 0;" einen Breakpoint (um alle Variablen am Ende kontrollieren zu können).

Für die folgenden Screenshots wurden nur Breakpoints in den Zeilen 13 und 26 gesetzt (und nicht in Zeile 6).

Ein Breakpoint kann durch erneutes Anklicken (auf den roten Kreis) wieder gelöscht werden.

Der Start des Debuggers (und damit der Start des Executables) erfolgt durch Anwahl des Menüs "Debug" und des Punktes "Start".

Schrittweiser Ablauf im Debugger

Nach dem Start im Debugger läuft das Executable mit dem Sourcecode

bis es an einen Haltepunkt ankommt und stoppt, oder bis das Programmende erreicht ist.

Es erscheint ein neues DOS-Box-Fenster (mit dem Namen des Executables):

Das Fortsetzen geschieht z.B. durch Anwahl des Menüs "Debug" und des Punktes "Next Line" (oder kurz durch das Tastaturkürzel F7):

Dabei zeigt das gelbe Dreieck rechts neben der Zeilennummer die aktuelle Sourcecodezeile, die als nächstes ablaufen soll.
Der obige Screenshot zeigt das Executable nach dem Anhalten durch den Breakpoint in Zeile 13. Im Screenshot sieht man das Editorfenster, nachdem "Next Line" nach dem Erreichen des Breakpoints in Zeile 13 angewählt worden. Das gelbe Dreieck zeigt an, dass Zeile 14 die nächste auszuführende Anweisung ist (d.h. die Eingabe in die Variable "a" ist noch nicht erfolgt).
Erst beim nächsten "Next Line" kann man im DOS-Fenster den Variablenwert (im Beispiel: 3) für "a" eingeben. Nach diesem "Next Line" zeigt das Fenster "Watches"

(rot hervorgehoben) den neuen Wert 3 der lokalen Variable "a". Die anderen Variablen "b,c,Flaeche" sind noch uninitialisiert (und haben kaum vorhersehbare Werte).

Alternativ kann man statt "Next Line" im Debugmenü "Continue" anwählen, dann wird der Ablauf des Executables fortgesetzt (notfalls nur bis zum nächsten Breakpoint ...).

Den Punkt "Next Instruction" sollte man nicht anwählen, dann läuft auf Assemblerebene in einem Disassembly-Fenster die nächste Prozessoranweisung ab (eine Sourcecodezeile wird normalerweise auf Assemblerebene durch viele Prozessoranweisungen realisiert). Da ein Debuggen auf Assemblerebene meist viel zu speziell und sehr mühsam ist, sollte man diesen Modus schnell mit "Next Line" abschließen.

top