Tutorials

C und C++ Programme in Visual Studio Code mit GDB und G++ debuggen: Schritt-für-Schritt-Anleitung

Melden

Visual Studio Code (VS Code) ist ein extrem beliebter und leichtgewichtiger Editor, der sich mit den richtigen Erweiterungen in eine vollwertige Entwicklungsumgebung (IDE) für C und C++ verwandeln lässt. In dieser Anleitung lernst du, wie du deinen C/C++-Code mit dem G++-Compiler kompilierst und Fehler mithilfe des GDB (GNU Debugger) direkt in VS Code findest und behebst.

1. Voraussetzungen

Bevor wir in VS Code starten, müssen der Compiler und der Debugger auf deinem Betriebssystem installiert und über das Terminal erreichbar sein.

  • Linux (Ubuntu/Debian):
    sudo apt update
sudo apt install build-essential gdb
  • Windows: Installiere MinGW-w64 (z. B. über MSYS2) und stelle sicher, dass der Pfad zum bin-Ordner (enthält g++.exe und gdb.exe) in den System-Umgebungsvariablen (PATH) hinterlegt ist.
  • macOS: Installiere die Command Line Tools via Terminal:
    xcode-select --install

    (Hinweis: Auf dem Mac wird standardmäßig clang und lldb genutzt, die Vorgehensweise ist aber nahezu identisch).

Überprüfung im Terminal: Gib folgende Befehle ein, um zu prüfen, ob alles bereit ist:

g++ --version
gdb --version

2. VS Code vorbereiten

  1. Öffne VS Code.
  2. Gehe links auf das Symbol für Erweiterungen (Extensions) oder drücke Strg + Umschalt + X.
  3. Suche nach C/C++ (von Microsoft) und installiere die Erweiterung. Sie liefert IntelliSense, Code-Navigation und Debugging-Unterstützung.

3. Ein Beispiel-Projekt erstellen

  1. Erstelle auf deinem Computer einen neuen, leeren Ordner (z. B. cpp_debug_demo) und öffne diesen Ordner in VS Code (Datei > Ordner öffnen...).
  2. Erstelle eine neue Datei namens main.cpp (oder main.c, falls du reines C nutzt).
  3. Füge folgenden fehleranfälligen Beispielcode ein:
#include <iostream>

void printCount(int count) {
    std::cout << "Aktueller Zählerstand: " << count << std::endl;
}

int main() {
    int sum = 0;

    for (int i = 1; i <= 5; ++i) {
        sum += i;
        printCount(sum);
    }

    std::cout << "Gesamtsumme: " << sum << std::endl;
    return 0;
}

4. Build-Task einrichten (tasks.json)

Bevor wir debuggen können, muss der Quellcode in Maschinensprache übersetzt werden. Dabei ist das Flag -g zwingend erforderlich, da es dem Debugger wichtige Informationen (Debug-Symbole) zur Verfügung stellt.

  1. Drücke Strg + Umschalt + P, um die Befehlspalette zu öffnen.
  2. Tippe Tasks: Configure Default Build Task ein und wähle es aus.
  3. Wähle C/C++: g++ build active file (oder gcc für C).
  4. VS Code erstellt nun einen Ordner namens .vscode mit einer tasks.json. Sie sollte ungefähr so aussehen:
{
    "version": "2.0.0",
    "tasks": [
        {
            "type": "cppbuild",
            "label": "C/C++: g++ build active file",
            "command": "g++",
            "args": [
                "-g", // SEHR WICHTIG: Fügt Debug-Symbole hinzu!
                "${file}",
                "-o",
                "${fileDirname}/${fileBasenameNoExtension}" // Unter Windows: ...NoExtension}.exe"
            ],
            "options": {
                "cwd": "${fileDirname}"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "detail": "Compiler: g++"
        }
    ]
}

5. Debugger einrichten (launch.json)

Nun verknüpfen wir den Debugger mit dem erstellten Programm.

  1. Drücke Strg + Umschalt + D, um das Menü Ausführen und Debuggen auf der linken Seite zu öffnen.
  2. Klicke auf den blauen Link: Eine Datei 'launch.json' erstellen.
  3. Wähle C++ (GDB/LLDB).
  4. Klicke unten rechts auf Konfiguration hinzufügen und wähle C/C++: (gdb) Launch.
  5. Passe die erstellte launch.json wie folgt an:
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "(gdb) Launch",
            "type": "cppdbg",
            "request": "launch",
            // Pfad zur erstellten ausführbaren Datei
            "program": "${fileDirname}/${fileBasenameNoExtension}", // Windows: ...NoExtension}.exe
            "args": [],
            "stopAtEntry": false,
            "cwd": "${fileDirname}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ],
            "preLaunchTask": "C/C++: g++ build active file", // Muss exakt dem 'label' aus tasks.json entsprechen!
            "miDebuggerPath": "gdb" // Unter Windows ggf. voller Pfad, z.B.: "C:/msys64/ucrt64/bin/gdb.exe"
        }
    ]
}

Wichtig: Durch "preLaunchTask" kompiliert VS Code das Programm automatisch neu, bevor der Debugger gestartet wird.

6. Den Debugger nutzen

Gehe zurück zu deiner main.cpp. Jetzt beginnt das eigentliche Debuggen:

1. Haltepunkte (Breakpoints) setzen

Klicke mit der Maus links neben die Zeilennummer von sum += i; (im Schleifenkörper). Es erscheint ein roter Punkt. Dies ist ein Haltepunkt. Das Programm wird hier im Debugging-Modus pausieren.

2. Debugging starten

Drücke F5 (oder klicke links oben im Ausführen-Reiter auf das grüne Play-Symbol).

  • VS Code kompiliert den Code im Hintergrund.
  • Das Programm startet und stoppt direkt an deinem Breakpoint.
  • Die aktuelle Zeile wird gelb hervorgehoben.

3. Die Steuerungselemente (oben mittig)

  • Fortsetzen / Weiter (F5): Läuft bis zum nächsten Breakpoint weiter.
  • Einzelschritt / Step Over (F10): Führt die aktuelle Zeile aus und springt zur nächsten (überspringt Funktionen, geht nicht hinein).
  • Einzelschritt in... / Step Into (F11): Springt in Funktionen hinein (z. B. in die Funktion printCount).
  • Einzelschritt heraus / Step Out (Umschalt + F11): Verlässt die aktuelle Funktion wieder.
  • Neu starten (Strg + Umschalt + F5): Startet das Debugging von vorne.
  • Stoppen (Umschalt + F5): Beendet die Debugging-Sitzung.

4. Das Kontrollfenster (Linke Leiste)

Während das Programm pausiert ist, kannst du links wertvolle Informationen einsehen:

  • Variablen: Siehe den aktuellen Wert von sum und i. Wenn du mit F10 weitergehst, siehst du, wie sich die Werte in Echtzeit verändern.
  • Überwachen (Watch): Hier kannst du eigene Ausdrücke oder Variablen eingeben (z. B. sum * 2 oder i == 3), um deren Zustand permanent zu beobachten.
  • Aufrufliste (Call Stack): Zeigt dir an, wo sich der Code gerade befindet und über welche Funktionsaufrufe er dorthin gelangt ist.

Häufige Fehlerquellen & Lösungen

  • Breakpoint wird nicht getroffen (Hohler grauer Kreis): Stelle sicher, dass in deiner tasks.json das Flag -g enthalten ist. Ohne dieses Flag weiß GDB nicht, welche Codezeile zu welcher Maschinenanweisung gehört.
  • "gdb: Befehl nicht gefunden" (Command not found): GDB ist entweder nicht installiert oder der Pfad dorthin fehlt in deiner PATH-Umgebungsvariable. Du kannst den direkten Pfad zu deiner gdb-Datei in der launch.json unter "miDebuggerPath" angeben.
  • Der Compiler baut eine Datei nicht, weil Pfade Leerzeichen enthalten: Verwende nach Möglichkeit keine Leerzeichen in deinen Ordner- oder Dateinamen (z. B. mein_projekt statt mein projekt).
0