Verwendung von C++ unter Linux in VS Code

In diesem Tutorial konfigurieren Sie Visual Studio Code für die Verwendung des GCC C++-Compilers (g++) und des GDB-Debuggers unter Linux. GCC steht für GNU Compiler Collection; GDB ist der GNU Debugger.

Nach der Konfiguration von VS Code kompilieren und debuggen Sie ein einfaches C++-Programm in VS Code. Dieses Tutorial lehrt Sie nicht GCC, GDB, Ubuntu oder die C++-Sprache. Für diese Themen gibt es viele gute Ressourcen im Web.

Wenn Sie Probleme haben, können Sie gerne ein Problem für dieses Tutorial im VS Code Dokumentationsrepository melden.

Voraussetzungen

Um dieses Tutorial erfolgreich abzuschließen, müssen Sie Folgendes tun:

1. Installieren Sie Visual Studio Code.

2. Installieren Sie die C++-Erweiterung für VS Code. Sie können die C/C++-Erweiterung installieren, indem Sie im Erweiterungs-Explorer nach 'c++' suchen (Ansicht: ⇧⌘X (Windows, Linux Ctrl+Shift+X)).

   

Stellen Sie sicher, dass GCC installiert ist

Obwohl Sie VS Code zum Bearbeiten Ihres Quellcodes verwenden, kompilieren Sie den Quellcode unter Linux mit dem g++-Compiler. Sie verwenden auch GDB zum Debuggen. Diese Werkzeuge sind unter Ubuntu nicht standardmäßig installiert, daher müssen Sie sie installieren. Glücklicherweise ist das einfach.

Überprüfen Sie zunächst, ob GCC bereits installiert ist. Um dies zu überprüfen, öffnen Sie ein Terminalfenster und geben Sie den folgenden Befehl ein:

gcc -v

Wenn GCC nicht installiert ist, führen Sie den folgenden Befehl im Terminalfenster aus, um die Paketlisten von Ubuntu zu aktualisieren. Eine veraltete Linux-Distribution kann manchmal die Installation neuer Pakete behindern.

sudo apt-get update

Installieren Sie als Nächstes die GNU-Compiler-Tools und den GDB-Debugger mit diesem Befehl:

sudo apt-get install build-essential gdb

Hello World erstellen

Erstellen Sie im Terminalfenster einen leeren Ordner namens projects, um Ihre VS Code-Projekte zu speichern. Erstellen Sie dann einen Unterordner namens helloworld, navigieren Sie hinein und öffnen Sie VS Code in diesem Ordner, indem Sie die folgenden Befehle eingeben:

mkdir projects
cd projects
mkdir helloworld
cd helloworld
code .

Der Befehl code . öffnet VS Code im aktuellen Arbeitsordner, der zu Ihrem "Arbeitsbereich" wird. Während Sie das Tutorial durchlaufen, werden Sie drei Dateien in einem Ordner namens .vscode im Arbeitsbereich erstellen:

• tasks.json (Kompilierungs-Build-Einstellungen)
• launch.json (Debugger-Einstellungen)
• c_cpp_properties.json (Compilerpfad- und IntelliSense-Einstellungen)

Datei mit Hello World-Quellcode hinzufügen

Wählen Sie in der Titelleiste des Datei-Explorers Neue Datei und nennen Sie die Datei helloworld.cpp.

Fügen Sie den folgenden Quellcode ein:

#include <iostream>
#include <vector>
#include <string>

using namespace std;

int main()
{
    vector<string> msg {"Hello", "C++", "World", "from", "VS Code", "and the C++ extension!"};

    for (const string& word : msg)
    {
        cout << word << " ";
    }
    cout << endl;

    return 0;
}

Drücken Sie nun ⌘S (Windows, Linux Ctrl+S), um die Datei zu speichern. Beachten Sie, dass Ihre Dateien in der Ansicht Datei-Explorer (⇧⌘E (Windows, Linux Ctrl+Shift+E)) in der Seitenleiste von VS Code aufgeführt sind.

Sie können auch Auto Save aktivieren, um Ihre Dateiänderungen automatisch zu speichern, indem Sie im Hauptmenü Datei die Option Auto Save auswählen.

Die Aktivitätsleiste am Rand von Visual Studio Code ermöglicht Ihnen das Öffnen verschiedener Ansichten wie Suchen, Quellcodeverwaltung und Ausführen. Die Ansicht Ausführen werden Sie später in diesem Tutorial betrachten. Weitere Informationen zu den anderen Ansichten finden Sie in der VS Code-Dokumentation zur Benutzeroberfläche.

Hinweis: Wenn Sie eine C++-Datei speichern oder öffnen, sehen Sie möglicherweise eine Benachrichtigung von der C/C++-Erweiterung über die Verfügbarkeit einer Insiders-Version, mit der Sie neue Funktionen und Korrekturen testen können. Sie können diese Benachrichtigung ignorieren, indem Sie auf das X (Benachrichtigung löschen) klicken.

IntelliSense erkunden

Zeigen Sie im helloworld.cpp-Datei mit der Maus auf vector oder string, um Typinformationen zu sehen. Geben Sie nach der Deklaration der Variable msg msg. ein, als ob Sie eine Member-Funktion aufrufen würden. Sie sollten sofort eine Vervollständigungsliste mit allen Member-Funktionen sehen und ein Fenster, das die Typinformationen für das Objekt msg anzeigt.

Sie können die Tabulatortaste drücken, um das ausgewählte Mitglied einzufügen. Wenn Sie dann die öffnende Klammer hinzufügen, sehen Sie Informationen zu den Argumenten, die die Funktion benötigt.

helloworld.cpp ausführen

Denken Sie daran, dass die C++-Erweiterung den C++-Compiler verwendet, den Sie auf Ihrem Rechner installiert haben, um Ihr Programm zu erstellen. Stellen Sie sicher, dass Sie einen C++-Compiler installiert haben, bevor Sie versuchen, helloworld.cpp in VS Code auszuführen und zu debuggen.

1. Öffnen Sie helloworld.cpp, sodass es die aktive Datei ist.

2. Drücken Sie die Wiedergabetaste oben rechts im Editor.

   

3. Wählen Sie g++ build and debug active file aus der Liste der erkannten Compiler auf Ihrem System aus.

   

Sie werden nur beim ersten Ausführen von helloworld.cpp aufgefordert, einen Compiler auszuwählen. Dieser Compiler wird als "Standard"-Compiler in der Datei tasks.json festgelegt.

4. Nachdem der Build erfolgreich war, wird die Ausgabe Ihres Programms im integrierten Terminal angezeigt.

   

Wenn Sie Ihr Programm zum ersten Mal ausführen, erstellt die C++-Erweiterung tasks.json, die Sie im .vscode-Ordner Ihres Projekts finden. tasks.json speichert Build-Konfigurationen.

Ihre neue Datei tasks.json sollte der folgenden JSON-Datei ähneln:

{
  "version": "2.0.0",
  "tasks": [
    {
      "type": "shell",
      "label": "C/C++: g++ build active file",
      "command": "/usr/bin/g++",
      "args": ["-g", "${file}", "-o", "${fileDirname}/${fileBasenameNoExtension}"],
      "options": {
        "cwd": "/usr/bin"
      },
      "problemMatcher": ["$gcc"],
      "group": {
        "kind": "build",
        "isDefault": true
      },
      "detail": "Task generated by Debugger."
    }
  ]
}

Hinweis: Weitere Informationen zu tasks.json-Variablen finden Sie in der Variablenreferenz.

Die Einstellung command gibt das auszuführende Programm an; in diesem Fall ist dies g++. Das Array args gibt die Befehlszeilenargumente an, die an g++ übergeben werden. Diese Argumente müssen in der vom Compiler erwarteten Reihenfolge angegeben werden.

Diese Aufgabe weist g++ an, die aktive Datei (${file}) zu kompilieren und eine ausführbare Datei im aktuellen Verzeichnis (${fileDirname}) mit demselben Namen wie die aktive Datei, aber ohne Erweiterung (${fileBasenameNoExtension}), zu erstellen, was in unserem Beispiel helloworld ergibt.

Der Wert label ist das, was Sie in der Aufgabenliste sehen werden; Sie können diesen beliebig benennen.

Der Wert detail ist die Beschreibung der Aufgabe, die Sie in der Aufgabenliste sehen werden. Es wird dringend empfohlen, diesen Wert umzubenennen, um ihn von ähnlichen Aufgaben zu unterscheiden.

Von nun an liest die Wiedergabetaste aus tasks.json, um zu ermitteln, wie Ihr Programm erstellt und ausgeführt werden soll. Sie können mehrere Build-Aufgaben in tasks.json definieren, und die als Standard markierte Aufgabe wird von der Wiedergabetaste verwendet. Falls Sie den Standardcompiler ändern müssen, können Sie Tasks: Configure default build task ausführen. Alternativ können Sie die Datei tasks.json ändern und dieses Segment entfernen, indem Sie es ersetzen

    "group": {
        "kind": "build",
        "isDefault": true
    },

durch dieses:

    "group": "build",

Ändern von tasks.json

Sie können Ihre tasks.json ändern, um mehrere C++-Dateien zu kompilieren, indem Sie ein Argument wie "${workspaceFolder}/*.cpp" anstelle von "${file}" verwenden. Dies kompiliert alle .cpp-Dateien in Ihrem aktuellen Ordner. Sie können auch den Ausgabedateinamen ändern, indem Sie "${fileDirname}/${fileBasenameNoExtension}" durch einen fest codierten Dateinamen ersetzen (z. B. 'helloworld.out').

helloworld.cpp debuggen

Um Ihren Code zu debuggen,

1. Kehren Sie zu helloworld.cpp zurück, sodass es die aktive Datei ist.
2. Legen Sie einen Haltepunkt fest, indem Sie in den Rand des Editors klicken oder F9 für die aktuelle Zeile verwenden.
3. Wählen Sie aus dem Dropdown-Menü neben der Wiedergabetaste Debug C/C++ File aus.
4. Wählen Sie C/C++: g++ build and debug active file aus der Liste der erkannten Compiler auf Ihrem System aus (Sie werden nur beim ersten Ausführen oder Debuggen von helloworld.cpp aufgefordert, einen Compiler auszuwählen).

Die Wiedergabetaste hat zwei Modi: Run C/C++ File und Debug C/C++ File. Sie wird standardmäßig auf den zuletzt verwendeten Modus eingestellt. Wenn Sie das Debug-Symbol auf der Wiedergabetaste sehen, können Sie einfach die Wiedergabetaste auswählen, um zu debuggen, anstatt das Dropdown-Menü auszuwählen.

Den Debugger erkunden

Bevor Sie mit dem schrittweisen Durchgehen des Codes beginnen, nehmen Sie sich einen Moment Zeit, um mehrere Änderungen in der Benutzeroberfläche zu bemerken:

• Das integrierte Terminal erscheint am unteren Rand des Quellcode-Editors. Im Tab Debug Output sehen Sie eine Ausgabe, die anzeigt, dass der Debugger läuft.

• Der Editor hebt Zeile 12 hervor, was ein Haltepunkt ist, den Sie vor dem Start des Debuggers gesetzt haben.

  

• Die Ansicht Run and Debug auf der linken Seite zeigt Debug-Informationen an. Ein Beispiel sehen Sie später im Tutorial.

• Oben im Code-Editor erscheint eine Debugging-Steuerleiste. Sie können diese durch Ziehen der Punkte auf der linken Seite auf dem Bildschirm verschieben.

  

Wenn Sie bereits eine launch.json-Datei in Ihrem Arbeitsbereich haben, liest die Wiedergabetaste daraus beim Ermitteln, wie Ihre C++-Datei ausgeführt und debuggt werden soll. Wenn Sie keine launch.json haben, erstellt die Wiedergabetaste im Handumdrehen eine temporäre "Quick Debug"-Konfiguration, wodurch launch.json überflüssig wird!

Den Code schrittweise durchgehen

Jetzt können Sie mit dem schrittweisen Durchgehen des Codes beginnen.

1. Klicken oder drücken Sie auf das Symbol Step over in der Debugging-Steuerleiste.

   

   Dies wird die Programmausführung zur ersten Zeile der for-Schleife fortsetzen und alle internen Funktionsaufrufe innerhalb der Klassen vector und string überspringen, die aufgerufen werden, wenn die Variable msg erstellt und initialisiert wird. Beachten Sie die Änderung im Fenster Variablen auf der Seite.

   

2. Drücken Sie erneut Step over, um zur nächsten Anweisung in diesem Programm zu gelangen (wobei aller interne Code übersprungen wird, der zur Initialisierung der Schleife ausgeführt wird). Jetzt zeigt das Fenster Variablen Informationen über die Schleifenvariablen an.

3. Drücken Sie erneut Step over, um die cout-Anweisung auszuführen. (Beachten Sie, dass die C++-Erweiterung keine Ausgabe in der Debug Console ausgibt, bis die letzte cout ausgeführt wird.)

4. Wenn Sie möchten, können Sie weiterhin Step over drücken, bis alle Wörter im Vektor auf der Konsole ausgegeben wurden. Aber wenn Sie neugierig sind, versuchen Sie, die Schaltfläche Step Into zu drücken, um den Quellcode in der C++-Standardbibliothek schrittweise durchzugehen!

   

   Um zu Ihrem eigenen Code zurückzukehren, können Sie entweder mehrmals Step over drücken. Eine andere Möglichkeit ist, einen Haltepunkt in Ihrem Code zu setzen, indem Sie zum Tab helloworld.cpp im Code-Editor wechseln, den Einfügepunkt irgendwo in der cout-Anweisung innerhalb der Schleife platzieren und F9 drücken. Ein roter Punkt erscheint in der linken Spalte, um anzuzeigen, dass auf dieser Zeile ein Haltepunkt gesetzt wurde.

   

   Drücken Sie dann F5, um die Ausführung ab der aktuellen Zeile in der Standardbibliotheksdatei zu starten. Die Ausführung wird bei cout unterbrochen. Wenn Sie möchten, können Sie erneut F9 drücken, um den Haltepunkt zu deaktivieren.

   Wenn die Schleife abgeschlossen ist, können Sie die Ausgabe im Tab Debug Console des integrierten Terminals zusammen mit einigen anderen Diagnoseinformationen sehen, die von GDB ausgegeben werden.

   

Eine Überwachung (Watch) einrichten

Um den Wert einer Variablen während der Programmausführung zu verfolgen, legen Sie eine Überwachung (Watch) für die Variable fest.

1. Platzieren Sie den Einfügepunkt innerhalb der Schleife. Klicken Sie im Fenster Watch auf das Pluszeichen und geben Sie im Textfeld word ein, was der Name der Schleifenvariable ist. Betrachten Sie nun das Fenster "Watch", während Sie die Schleife schrittweise durchgehen.

   

2. Um den Wert einer beliebigen Variablen schnell anzuzeigen, während die Ausführung bei einem Haltepunkt pausiert ist, können Sie mit der Maus darüber fahren.

   

Als Nächstes erstellen Sie eine Datei tasks.json, um VS Code mitzuteilen, wie das Programm erstellt (kompiliert) werden soll. Diese Aufgabe wird den g++-Compiler aufrufen, um aus dem Quellcode eine ausführbare Datei zu erstellen.

Es ist wichtig, dass helloworld.cpp im Editor geöffnet ist, da der nächste Schritt die aktive Datei im Editor als Kontext verwendet, um die Build-Aufgabe im nächsten Schritt zu erstellen.

Debugging mit launch.json anpassen

Wenn Sie mit der Wiedergabetaste oder F5 debuggen, erstellt die C++-Erweiterung eine dynamische Debug-Konfiguration im Handumdrehen.

Es gibt Fälle, in denen Sie Ihre Debug-Konfiguration anpassen möchten, z. B. das Angeben von Argumenten, die zur Laufzeit an das Programm übergeben werden sollen. Sie können benutzerdefinierte Debug-Konfigurationen in einer Datei launch.json definieren.

Um launch.json zu erstellen, wählen Sie im Dropdown-Menü der Wiedergabetaste Add Debug Configuration aus.

Sie sehen dann ein Dropdown-Menü mit verschiedenen vordefinierten Debugging-Konfigurationen. Wählen Sie g++ build and debug active file.

VS Code erstellt eine Datei launch.json, die ungefähr so aussieht:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "C/C++: g++ build and debug active file",
      "type": "cppdbg",
      "request": "launch",
      "program": "${fileDirname}/${fileBasenameNoExtension}",
      "args": [],
      "stopAtEntry": false,
      "cwd": "${workspaceFolder}",
      "environment": [],
      "externalConsole": false,
      "MIMode": "gdb",
      "miDebuggerPath": "/usr/bin/gdb",
      "setupCommands": [
        {
          "description": "Enable pretty-printing for gdb",
          "text": "-enable-pretty-printing",
          "ignoreFailures": true
        }
      ],
      "preLaunchTask": "C/C++: g++ build active file"
    }
  ]
}

Im obigen JSON gibt program das Programm an, das Sie debuggen möchten. Hier ist es auf den Ordner der aktiven Datei ${fileDirname} und den aktiven Dateinamen ohne Erweiterung ${fileBasenameNoExtension} eingestellt, was, wenn helloworld.cpp die aktive Datei ist, helloworld sein wird. Die Eigenschaft args ist ein Array von Argumenten, die zur Laufzeit an das Programm übergeben werden.

Standardmäßig fügt die C++-Erweiterung keine Haltepunkte in Ihren Quellcode ein und der Wert stopAtEntry ist auf false gesetzt.

Ändern Sie den Wert stopAtEntry auf true, damit der Debugger bei der Methode main anhält, wenn Sie mit dem Debugging beginnen.

Von nun an lesen die Wiedergabetaste und F5 aus Ihrer Datei launch.json, wenn Sie Ihr Programm zum Debuggen starten.

C/C++-Konfigurationen

Wenn Sie mehr Kontrolle über die C/C++-Erweiterung wünschen, können Sie eine Datei c_cpp_properties.json erstellen, mit der Sie Einstellungen wie den Pfad zum Compiler, Include-Pfade, den C++-Standard (Standard ist C++17) und mehr ändern können.

Sie können die C/C++-Konfigurationsoberfläche anzeigen, indem Sie den Befehl C/C++: Edit Configurations (UI) über die Befehlspalette (⇧⌘P (Windows, Linux Ctrl+Shift+P)) ausführen.

Dies öffnet die Seite C/C++ Configurations. Wenn Sie hier Änderungen vornehmen, schreibt VS Code diese in eine Datei namens c_cpp_properties.json im Ordner .vscode.

Sie müssen nur die Einstellung Include path ändern, wenn Ihr Programm Header-Dateien enthält, die sich nicht in Ihrem Arbeitsbereich oder im Standardbibliotheks-Pfad befinden.

Visual Studio Code speichert diese Einstellungen in .vscode/c_cpp_properties.json. Wenn Sie diese Datei direkt öffnen, sollte sie ungefähr so aussehen:

{
  "configurations": [
    {
      "name": "Linux",
      "includePath": ["${workspaceFolder}/**"],
      "defines": [],
      "compilerPath": "/usr/bin/gcc",
      "cStandard": "c11",
      "cppStandard": "c++17",
      "intelliSenseMode": "clang-x64"
    }
  ],
  "version": 4
}

Wiederverwendung Ihrer C++-Konfiguration

VS Code ist nun für die Verwendung von gcc unter Linux konfiguriert. Die Konfiguration gilt für den aktuellen Arbeitsbereich. Um die Konfiguration wiederzuverwenden, kopieren Sie einfach die JSON-Dateien in einen Ordner namens .vscode in einem neuen Projektordner (Arbeitsbereich) und ändern Sie die Namen der Quellendatei(en) und der ausführbaren Datei nach Bedarf.

Fehlerbehebung

Compiler- und Linkerfehler

Die häufigste Ursache für Fehler (wie z. B. undefined _main oder attempting to link with file built for unknown-unsupported file format usw.) tritt auf, wenn helloworld.cpp nicht die aktive Datei ist, wenn Sie mit dem Erstellen oder Debuggen beginnen. Dies liegt daran, dass der Compiler versucht, etwas zu kompilieren, das kein Quellcode ist, wie Ihre launch.json, tasks.json oder c_cpp_properties.json-Datei.

Nächste Schritte

• Erkunden Sie den VS Code Benutzerhandbuch.
• Überprüfen Sie die Übersicht über die C++-Erweiterung.
• Erstellen Sie einen neuen Arbeitsbereich, kopieren Sie Ihre .json-Dateien hinein, passen Sie die notwendigen Einstellungen für den neuen Arbeitsbereichspfad, den Programmnamen usw. an und beginnen Sie mit dem Coden!