Clang unter Visual Studio Code verwenden

In diesem Tutorial konfigurieren Sie Visual Studio Code unter macOS so, dass der Clang/LLVM-Compiler und Debugger verwendet wird.

Nachdem Sie VS Code konfiguriert haben, kompilieren und debuggen Sie ein C++-Programm in VS Code. Dieses Tutorial lehrt Sie nicht Clang oder die C++-Sprache. Für diese Themen gibt es viele gute Ressourcen im Web.

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

Voraussetzungen

Um dieses Tutorial erfolgreich abzuschließen, müssen Sie die folgenden Schritte ausführen

Installieren Sie Visual Studio Code unter macOS.
Installieren Sie die C++-Erweiterung für VS Code. Sie können die C/C++-Erweiterung installieren, indem Sie in der Ansicht Erweiterungen nach "C++" suchen (drücken Sie ⇧⌘X (Windows, Linux Ctrl+Shift+X)).

Stellen Sie sicher, dass Clang installiert ist

Clang ist möglicherweise bereits auf Ihrem Mac installiert. Um zu überprüfen, ob dies der Fall ist, öffnen Sie ein macOS Terminal-Fenster und geben Sie den folgenden Befehl ein

clang --version

Wenn Clang nicht installiert ist, geben Sie den folgenden Befehl ein, um die Befehlszeilen-Entwicklertools zu installieren, die Clang enthalten

xcode-select --install

Hallo Welt-App erstellen

Erstellen Sie im macOS Terminal einen leeren Ordner namens projects, in dem Sie alle Ihre VS Code-Projekte speichern können. Erstellen Sie dann einen Unterordner namens helloworld, navigieren Sie hinein und öffnen Sie VS Code in diesem Ordner, indem Sie die folgenden Befehle im Terminalfenster eingeben

mkdir projects
cd projects
mkdir helloworld
cd helloworld
code .

Der Befehl code . öffnet VS Code im aktuellen Arbeitsordner, der zu Ihrer "Arbeitsumgebung" wird. Während Sie das Tutorial durchlaufen, werden im Ordner .vscode in Ihrer Arbeitsumgebung drei Dateien erstellt

tasks.json (Kompilierungsbuild-Einstellungen)
launch.json (Debugger-Einstellungen)
c_cpp_properties.json (Compilerpfad- und IntelliSense-Einstellungen)

Fügen Sie eine Hallo-Welt-Quelldatei hinzu

Wählen Sie in der Titelleiste des Datei-Explorers die Schaltfläche Neue Datei und benennen 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;
}

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

File Explorer

Sie können auch die Funktion **Automatisch speichern** aktivieren, indem Sie **Datei** > **Automatisch speichern** auswählen. Weitere Informationen zu den anderen Ansichten finden Sie in der Benutzeroberflächendokumentation von VS Code.

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

IntelliSense ist ein Tool, das Ihnen hilft, schneller und effizienter zu programmieren, indem es Funktionen zur Codebearbeitung wie Codevervollständigung, Parameterinformationen, Schnellinformationen und Memberlisten hinzufügt.

Um IntelliSense in Aktion zu sehen, bewegen Sie den Mauszeiger über vector oder string, um deren Typinformationen anzuzeigen. Wenn Sie in Zeile 10 msg. eingeben, sehen Sie eine Liste empfohlener Memberfunktionen, die aufgerufen werden können, alles generiert von IntelliSense

Statement completion IntelliSense

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

Wenn IntelliSense noch nicht konfiguriert ist, öffnen Sie die Befehlspalette (⇧⌘P (Windows, Linux Ctrl+Shift+P)) und geben Sie IntelliSense-Konfiguration auswählen ein. Wählen Sie aus der Dropdown-Liste der Compiler clang++ verwenden aus, um sie zu konfigurieren. Weitere Informationen finden Sie in der Dokumentation zur IntelliSense-Konfiguration.

helloworld.cpp ausführen

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

Öffnen Sie helloworld.cpp, sodass es die aktive Datei ist.
Drücken Sie die Wiedergabetaste oben rechts im Editor.
Wählen Sie C/C++: clang++ aktives Datei erstellen und debuggen aus der Liste der erkannten Compiler auf Ihrem System.

Sie werden nur aufgefordert, einen Compiler auszuwählen, wenn Sie helloworld.cpp zum ersten Mal ausführen. Dieser Compiler ist der "Standard"-Compiler, der in der Datei tasks.json festgelegt ist.

Nachdem das Erstellen erfolgreich war, wird die Ausgabe Ihres Programms in der integrierten **Debug-Konsole** angezeigt.

Herzlichen Glückwunsch! Sie haben gerade Ihr erstes C++-Programm in VS Code ausgeführt!

Verständnis von tasks.json

Beim ersten Ausführen Ihres Programms erstellt die C++-Erweiterung die Datei tasks.json, die sich im Ordner .vscode Ihres Projekts befindet. tasks.json speichert Build-Konfigurationen.

Hier ist ein Beispiel für eine tasks.json-Datei unter macOS

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

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 das clang++.

Das Array args gibt die Befehlszeilenargumente an, die an clang++ übergeben werden. Diese Argumente müssen in der Reihenfolge angegeben werden, in der sie vom Compiler erwartet werden.

Diese Aufgabe weist den C++-Compiler an, die aktive Datei (${file}) zu kompilieren und eine Ausgabedatei (-o-Schalter) im aktuellen Verzeichnis (${fileDirname}) mit demselben Namen wie die aktive Datei, aber ohne Dateierweiterung (${fileBasenameNoExtension}) zu erstellen. Dieser Prozess erstellt helloworld.

Der Wert label ist das, was Sie in der Aufgabenliste sehen, basierend auf Ihren persönlichen Vorlieben.

Der Wert detail ist die Beschreibung der Aufgabe in der Aufgabenliste. Aktualisieren Sie diese Zeichenfolge, um sie von ähnlichen Aufgaben zu unterscheiden.

Der Wert problemMatcher wählt den Ausgabe-Parser aus, der zum Finden von Fehlern und Warnungen in der Compiler-Ausgabe verwendet wird. Für clang++ liefert der $gcc-Problem-Matcher die besten Ergebnisse.

Von nun an liest die Play-Schaltfläche immer aus tasks.json, um herauszufinden, wie Ihr Programm erstellt und ausgeführt wird. Sie können mehrere Build-Aufgaben in tasks.json definieren, und die als Standard markierte Aufgabe wird von der Play-Schaltfläche verwendet. Falls Sie den Standard-Compiler ändern müssen, können Sie Aufgaben: Standard-Buildaufgabe konfigurieren in der Befehlspalette ausführen. Alternativ können Sie die Datei tasks.json ändern und dieses Segment durch Entfernen 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 erstellen, indem Sie ein Argument wie "${workspaceFolder}/*.cpp" anstelle von "${file}" verwenden. Dies erstellt alle .cpp-Dateien in Ihrem aktuellen Ordner. Sie können auch den Namen der Ausgabedatei ändern, indem Sie "${fileDirname}/${fileBasenameNoExtension}" durch einen fest codierten Dateinamen ersetzen (z. B. "${workspaceFolder}/myProgram.out").

helloworld.cpp debuggen

Um Ihren Code zu debuggen,

Kehren Sie zu helloworld.cpp zurück, sodass es die aktive Datei ist.
Setzen Sie einen Haltepunkt, indem Sie auf den Rand des Editors klicken oder F9 auf der aktuellen Zeile verwenden.
Wählen Sie aus dem Dropdown-Menü neben der Play-Schaltfläche C/C++-Datei erstellen und debuggen aus.
Wählen Sie C/C++: clang++ aktives Datei erstellen und debuggen aus der Liste der erkannten Compiler auf Ihrem System (Sie werden nur aufgefordert, einen Compiler auszuwählen, wenn Sie helloworld.cpp zum ersten Mal ausführen oder debuggen).
Sie sehen, wie die Aufgabe ausgeführt wird und die Ausgabe im **Terminal**-Fenster angezeigt wird.

Die Play-Schaltfläche hat zwei Modi: **C/C++-Datei ausführen** und **C/C++-Datei debuggen**. Der Standard ist der zuletzt verwendete Modus. Wenn Sie das Debug-Symbol auf der Play-Schaltfläche sehen, können Sie die Play-Schaltfläche zum Debuggen auswählen, 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-Konsole** sehen Sie Ausgaben, die darauf hinweisen, dass der Debugger läuft.
Der Editor hebt die Zeile hervor, in der Sie einen Haltepunkt gesetzt haben, bevor Sie den Debugger starten
Die Ansicht **Ausführen und Debuggen** in der Aktivitätsleiste zeigt Debugging-Informationen an.
Oben im Code-Editor erscheint eine Debugging-Steuerleiste. Sie können diese durch Ziehen der Punkte auf der linken Seite auf dem Bildschirm verschieben.

Den Code schrittweise durchgehen

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

Wählen Sie das Symbol **Schritt über** im Debugging-Bedienfeld aus, sodass die Anweisung for (const string& word : msg) hervorgehoben wird.

Der Befehl **Schritt über** überspringt alle internen Funktionsaufrufe innerhalb der Klassen vector und string, die aufgerufen werden, wenn die Variable msg erstellt und initialisiert wird. Beachten Sie die Änderung im Fenster **Variablen**. Der Inhalt von msg ist sichtbar, da diese Anweisung abgeschlossen ist.
Drücken Sie erneut **Schritt über**, um zur nächsten Anweisung zu gelangen (wobei der gesamte interne Code übersprungen wird, der zur Initialisierung der Schleife ausgeführt wird). Jetzt zeigt das Fenster **Variablen** Informationen über die Schleifenvariable an.
Drücken Sie erneut **Schritt über**, um die cout-Anweisung auszuführen.
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!

Eine Überwachung (Watch) einrichten

Möglicherweise möchten Sie den Wert einer Variablen im Auge behalten, während Ihr Programm ausgeführt wird. Sie können dies tun, indem Sie eine **Überwachung** für die Variable festlegen.

Wählen Sie im Fenster **Überwachung** das Pluszeichen aus und geben Sie word in das Textfeld ein. Dies ist der Name der Schleifenvariable. Betrachten Sie nun das Fenster **Überwachung**, während Sie durch die Schleife schrittweise vorgehen.

**Hinweis**: Der Wert der Überwachungsvariable ist nur verfügbar, wenn sich die Programmausführung im Gültigkeitsbereich der Variablen befindet. Zum Beispiel ist für eine Schleifenvariable der Wert nur verfügbar, wenn das Programm die Schleife ausführt.
Fügen Sie einen weiteren Watch hinzu, indem Sie diese Anweisung vor der Schleife hinzufügen: int i = 0;. Fügen Sie dann innerhalb der Schleife diese Anweisung hinzu: ++i;. Fügen Sie nun einen Watch für i hinzu, wie Sie es im vorherigen Schritt getan haben.
Sie können mit dem Mauszeiger über jede Variable schweben, während die Ausführung unterbrochen ist, um deren Wert schnell anzuzeigen.

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.

Add debug configuration play button menu

Sie sehen dann ein Dropdown-Menü für verschiedene vordefinierte Debugging-Konfigurationen. Wählen Sie C/C++: clang++ aktives Datei erstellen und debuggen. C++-Debug-Konfigurations-Dropdown

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

{
  "configurations": [
    {
      "name": "C/C++: clang++ build and debug active file",
      "type": "cppdbg",
      "request": "launch",
      "program": "${fileDirname}/${fileBasenameNoExtension}",
      "args": [],
      "stopAtEntry": false,
      "cwd": "${fileDirname}",
      "environment": [],
      "externalConsole": false,
      "MIMode": "lldb",
      "preLaunchTask": "C/C++: clang++ build active file"
    }
  ],
  "version": "2.0.0"
}

Die Einstellung program gibt das zu debuggende Programm an. Hier ist es auf den Ordner der aktiven Datei ${fileDirname} und den Namen der aktiven Datei ${fileBasenameNoExtension} eingestellt, was, wenn helloworld.cpp die aktive Datei ist, helloworld ergibt. 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.

Stellen Sie sicher, dass der Wert preLaunchTask mit dem label der Build-Aufgabe in der Datei tasks.json übereinstimmt.

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

Zusätzliche C/C++-Einstellungen hinzufügen

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

Zeigen Sie die C/C++-Konfigurations-UI an, indem Sie den Befehl C/C++: Konfigurationen bearbeiten (UI) aus der Befehlspalette (⇧⌘P (Windows, Linux Ctrl+Shift+P)) ausführen.

Command Palette

Dies öffnet die Seite **C/C++-Konfigurationen**.

C++ configuration

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": "Mac",
      "includePath": ["${workspaceFolder}/**"],
      "defines": [],
      "macFrameworkPath": [
        "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/System/Library/Frameworks"
      ],
      "compilerPath": "/usr/bin/clang",
      "cStandard": "c11",
      "cppStandard": "c++17",
      "intelliSenseMode": "macos-clang-arm64"
    }
  ],
  "version": 4
}

Sie müssen die Einstellung **Include-Pfad** nur dann ändern, wenn Ihr Programm Header-Dateien einschließt, die sich nicht in Ihrer Arbeitsumgebung oder im Pfad der Standardbibliothek befinden.

Compilerpfad

Die Erweiterung verwendet die Einstellung compilerPath, um den Pfad zu den Header-Dateien der C++-Standardbibliothek abzuleiten. Wenn die Erweiterung weiß, wo sie diese Dateien finden kann, kann sie Funktionen wie intelligente Vervollständigungen und die Navigation zu Definitionen bereitstellen.

Die C++-Erweiterung versucht, compilerPath mit dem Standard-Compiler-Speicherort basierend auf dem, was sie auf Ihrem System findet, zu füllen. Die Suchreihenfolge für compilerPath ist

Ihr PATH für die Namen bekannter Compiler. Die Reihenfolge, in der die Compiler in der Liste erscheinen, hängt von Ihrem PATH ab.
Dann werden fest codierte Xcode-Pfade durchsucht, wie z. B. /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/

Weitere Informationen finden Sie in der Dokumentation zur IntelliSense-Konfiguration.

Mac-Framework-Pfad

Scrollen Sie auf dem C/C++-Konfigurationsbildschirm nach unten, erweitern Sie **Erweiterte Einstellungen** und stellen Sie sicher, dass der **Mac-Framework-Pfad** auf die System-Header-Dateien zeigt. Zum Beispiel: /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/System/Library/Frameworks

Fehlerbehebung

Kompilierungs- und Linkfehler

Die häufigste Fehlerursache (wie z. B. undefined _main oder attempting to link with file built for unknown-unsupported file format und so weiter) tritt auf, wenn helloworld.cpp nicht die aktive Datei ist, wenn Sie einen Build starten oder mit dem Debugging beginnen. Dies liegt daran, dass der Compiler versucht, etwas zu kompilieren, das kein Quellcode ist, wie z. B. Ihre launch.json-, tasks.json- oder c_cpp_properties.json-Datei.

Wenn Sie Build-Fehler sehen, die "C++11-Erweiterungen" erwähnen, haben Sie möglicherweise Ihre tasks.json Build-Aufgabe nicht aktualisiert, um das clang++-Argument --std=c++17 zu verwenden. Standardmäßig verwendet clang++ den C++98-Standard, der die in helloworld.cpp verwendete Initialisierung nicht unterstützt. Stellen Sie sicher, dass Sie den gesamten Inhalt Ihrer tasks.json-Datei durch den Codeblock im Abschnitt Hallo Welt.cpp ausführen ersetzen.

Terminal startet nicht für Eingabe

Auf macOS Catalina und neueren Versionen können Sie das Problem haben, dass Sie keine Eingabe eingeben können, auch nachdem Sie "externalConsole": true gesetzt haben. Ein Terminalfenster wird geöffnet, aber Sie können keine Eingabe eingeben.

Das Problem wird derzeit unter #5079 verfolgt.

Die Problemumgehung besteht darin, VS Code das Terminal einmal starten zu lassen. Sie können dies tun, indem Sie diese Aufgabe zu Ihrer tasks.json hinzufügen und ausführen

{
  "label": "Open Terminal",
  "type": "shell",
  "command": "osascript -e 'tell application \"Terminal\"\ndo script \"echo hello\"\nend tell'",
  "problemMatcher": []
}

Sie können diese spezielle Aufgabe über **Terminal** > **Aufgabe ausführen...** ausführen und **Terminal öffnen** auswählen.

Sobald Sie die Berechtigungsanfrage akzeptiert haben, sollte die externe Konsole beim Debuggen erscheinen.

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!

12/14/2023