VS Code für Microsoft C++ konfigurieren

Name: Visual Studio Code
Author: Microsoft

In diesem Tutorial konfigurieren Sie Visual Studio Code, um den Microsoft Visual C++-Compiler und -Debugger unter Windows zu verwenden.

Nach der Konfiguration von VS Code kompilieren und debuggen Sie ein einfaches "Hallo Welt"-Programm in VS Code. Dieses Tutorial vermittelt Ihnen keine Details über das Microsoft C++-Toolset oder die C++-Sprache. Zu diesen Themen gibt es viele gute Ressourcen im Web.

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

Voraussetzungen

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

Installieren Sie Visual Studio Code.
Installieren Sie die C/C++-Erweiterung für VS Code. Sie können die C/C++-Erweiterung installieren, indem Sie in der Ansicht "Erweiterungen" nach 'c++' suchen (⇧⌘X (Windows, Linux Ctrl+Shift+X)).
Installieren Sie das Microsoft Visual C++ (MSVC)-Compiler-Toolset.

Wenn Sie eine neuere Version von Visual Studio haben, öffnen Sie das Visual Studio-Installationsprogramm über das Windows-Startmenü und vergewissern Sie sich, dass die C++-Workload aktiviert ist. Wenn sie nicht installiert ist, aktivieren Sie das Kontrollkästchen und wählen Sie die Schaltfläche Ändern im Installer.

Sie können auch die Workload Desktopentwicklung mit C++ installieren, ohne eine vollständige Visual Studio IDE-Installation. Scrollen Sie auf der Visual Studio Downloads-Seite nach unten, bis Sie unter dem Abschnitt Alle Downloads Tools für Visual Studio sehen, und wählen Sie den Download für Build Tools für Visual Studio 2022.

Dies startet das Visual Studio-Installationsprogramm, das ein Dialogfeld mit den verfügbaren Visual Studio Build Tools-Workloads anzeigt. Aktivieren Sie die Workload Desktopentwicklung mit C++ und wählen Sie Installieren.

Hinweis: Sie können das C++-Toolset von Visual Studio Build Tools zusammen mit Visual Studio Code verwenden, um C++-Code zu entwickeln, zu erstellen und zu testen, solange Sie auch eine gültige Visual Studio-Lizenz (Community, Pro oder Enterprise) besitzen.

Überprüfen Sie Ihre Microsoft Visual C++-Installation

Um MSVC von der Befehlszeile oder VS Code zu verwenden, müssen Sie von einer Eingabeaufforderung für Entwickler für Visual Studio aus arbeiten. Eine normale Shell wie PowerShell, Bash oder die Windows-Eingabeaufforderung verfügt nicht über die erforderlichen Pfad-Umgebungsvariablen.

Um die Eingabeaufforderung für Entwickler für VS zu öffnen, tippen Sie 'developer' im Windows-Startmenü ein, und Sie sollten sie in der Liste der Vorschläge sehen. Der genaue Name hängt von der Version von Visual Studio oder den Visual Studio Build Tools ab, die Sie installiert haben. Wählen Sie den Eintrag aus, um die Eingabeaufforderung zu öffnen.

Sie können testen, ob Sie den C++-Compiler cl.exe korrekt installiert haben, indem Sie 'cl' eingeben. Sie sollten eine Copyright-Meldung mit der Version und einer grundlegenden Nutzungsbeschreibung sehen.

Checking cl.exe installation

Wenn die Eingabeaufforderung für Entwickler das BuildTools-Verzeichnis als Startverzeichnis verwendet (Sie möchten keine Projekte dort ablegen), navigieren Sie zu Ihrem Benutzerordner (C:\users\{Ihr Benutzername}\), bevor Sie neue Projekte erstellen.

Hinweis: Wenn Sie VS Code aus irgendeinem Grund nicht über eine Eingabeaufforderung für Entwickler ausführen können, finden Sie eine Umgehungslösung zum Erstellen von C++-Projekten mit VS Code unter VS Code außerhalb einer Eingabeaufforderung für Entwickler ausführen.

Hallo Welt erstellen

Erstellen Sie von der Eingabeaufforderung für Entwickler aus 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 (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 "Workspace" wird. Während Sie das Tutorial durchlaufen, werden drei Dateien in einem Ordner namens .vscode im Workspace erstellt.

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

Eine Quellcodedatei hinzufügen

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 Hello-World-Quellcode hinzu

Fügen Sie nun diesen 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, wie die von Ihnen gerade hinzugefügte Datei im Datei-Explorer (⇧⌘E (Windows, Linux Ctrl+Shift+E)) in der Seitenleiste von VS Code angezeigt wird

File Explorer

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 ganz links ermöglicht es Ihnen, verschiedene Ansichten zu öffnen, z. B. Suchen, Quellcodeverwaltung und Ausführen. Die Ansicht Ausführen werden Sie später in diesem Tutorial untersuchen. 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

In Ihrer neuen Datei helloworld.cpp fahren Sie mit der Maus über vector oder string, um Typinformationen anzuzeigen. Nach der Deklaration der Variablen msg beginnen Sie mit der Eingabe von msg., wie Sie es beim Aufruf einer Member-Funktion tun würden. Sie sollten sofort eine Vervollständigungsliste sehen, die alle Member-Funktionen anzeigt, und ein Fenster, das die Typinformationen für das Objekt msg zeigt.

Statement completion IntelliSense

Sie können die Taste Tab drücken, um das ausgewählte Element einzufügen. Wenn Sie dann die öffnende Klammer hinzufügen, sehen Sie Informationen zu allen 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.

Öffnen Sie helloworld.cpp, sodass es die aktive Datei ist.
Drücken Sie die Wiedergabetaste oben rechts im Editor.
Wählen Sie C/C++: cl.exe build and debug active file aus der Liste der erkannten Compiler auf Ihrem System.

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.

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

Wenn Sie beim Erstellen und Debuggen mit cl.exe einen Fehler erhalten, stellen Sie sicher, dass Sie VS Code über die Eingabeaufforderung für Entwickler für Visual Studio gestartet haben und die Verknüpfung code . verwendet haben.

Error notification when trying to use MSVC without running VS Code from the Developer Command Prompt for VS

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++: cl.exe build active file",
      "command": "cl.exe",
      "args": [
        "/Zi",
        "/EHsc",
        "/Fe:",
        "${fileDirname}\\${fileBasenameNoExtension}.exe",
        "${file}"
      ],
      "problemMatcher": ["$msCompile"],
      "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 das "cl.exe". Das Array args gibt die Befehlszeilenargumente an, die an cl.exe übergeben werden. Diese Argumente müssen in der Reihenfolge angegeben werden, die der Compiler erwartet.

Diese Aufgabe weist den C++-Compiler an, die aktive Datei (${file}) zu nehmen, sie zu kompilieren und eine ausführbare Datei (/Fe:-Schalter) im aktuellen Verzeichnis (${fileDirname}) mit demselben Namen wie die aktive Datei, aber mit der Erweiterung .exe (${fileBasenameNoExtension}.exe) zu erstellen, was für unser Beispiel helloworld.exe 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 Aufgabenzusammenstellung sehen. Es wird dringend empfohlen, diesen Wert umzubenennen, um ihn 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 cl.exe erhalten Sie die besten Ergebnisse, wenn Sie den $msCompile-Problem-Matcher verwenden.

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 Ausgabenamen ändern, indem Sie "${fileDirname}\\${fileBasenameNoExtension}.exe" durch einen festen Dateinamen ersetzen (z. B. "${workspaceFolder}\\myProgram.exe").

helloworld.cpp debuggen

Um Ihren Code zu debuggen,

Kehren Sie zu helloworld.cpp zurück, sodass es die aktive Datei ist.
Legen Sie einen Haltepunkt fest, indem Sie in den Rand des Editors klicken oder F9 für die aktuelle Zeile verwenden.
Wählen Sie aus dem Dropdown-Menü neben der Wiedergabetaste Debug C/C++ File aus.
Wählen Sie C/C++: cl.exe build and debug active file 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).

Die Play-Schaltfläche hat zwei Modi: C/C++-Datei ausführen und C/C++-Datei debuggen. Sie wechselt standardmäßig zum zuletzt verwendeten Modus. Wenn Sie das Debug-Symbol in der Play-Schaltfläche sehen, können Sie die Play-Schaltfläche zum Debuggen auswählen, anstatt den Eintrag im Dropdown-Menü auszuwählen.

Error notification when trying to use MSVC without running VS Code from the Developer Command Prompt for VS

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 die Zeile hervor, in der Sie einen Haltepunkt gesetzt haben, bevor Sie den Debugger starten
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.

Den Code schrittweise durchgehen

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

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

Dies versetzt die Programmausführung bis zur ersten Zeile der for-Schleife fort und ü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 auf der linken Seite.

In diesem Fall sind die Fehler zu erwarten, da die Variablennamen für die Schleife zwar für den Debugger sichtbar sind, die Anweisung aber noch nicht ausgeführt wurde, sodass zu diesem Zeitpunkt nichts gelesen werden kann. Der Inhalt von msg ist jedoch sichtbar, da diese Anweisung abgeschlossen wurde.
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.
Drücken Sie erneut Schritt über, um die cout-Anweisung auszuführen. (Beachten Sie, dass die C++-Erweiterung erst dann Ausgaben in der Debug-Konsole anzeigt, wenn die Schleife beendet ist.)
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.

Eine Überwachung (Watch) einrichten

Manchmal möchten Sie den Wert einer Variablen während der Programmausführung verfolgen. Dies können Sie tun, indem Sie einen Watch (Überwachung) auf die Variable setzen.

Setzen Sie den Einfügepunkt innerhalb der Schleife. Wählen Sie im Fenster Watch das Pluszeichen aus und geben Sie im Textfeld word ein, was der Name der Schleifenvariable ist. Beobachten Sie nun das Watch-Fenster, während Sie die Schleife durchlaufen.
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.
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.

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ü mit verschiedenen vordefinierten Debug-Konfigurationen. Wählen Sie C/C++: cl.exe build and debug active file.

C++ debug configuration dropdown

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

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "C/C++: cl.exe build and debug active file",
      "type": "cppvsdbg",
      "request": "launch",
      "program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
      "args": [],
      "stopAtEntry": false,
      "cwd": "${workspaceFolder}",
      "environment": [],
      "externalConsole": false,
      "preLaunchTask": "C/C++: cl.exe build active file"
    }
  ]
}

In der obigen JSON-Datei gibt program das Programm an, das Sie debuggen möchten. Hier ist es auf den Ordner der aktiven Datei (${fileDirname}) und den Namen der aktiven Datei mit der Erweiterung .exe (${fileBasenameNoExtension}.exe) gesetzt, was bei helloworld.cpp als aktive Datei helloworld.exe 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.

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.

Command Palette

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.

Command Palette

Visual Studio Code speichert diese Einstellungen in .vscode\c_cpp_properties.json. Wenn Sie diese Datei direkt öffnen, sollte sie etwa so aussehen:

{
  "configurations": [
    {
      "name": "Win32",
      "includePath": ["${workspaceFolder}/**"],
      "defines": ["_DEBUG", "UNICODE", "_UNICODE"],
      "windowsSdkVersion": "10.0.18362.0",
      "compilerPath": "C:/Program Files (x86)/Microsoft Visual Studio/2019/BuildTools/VC/Tools/MSVC/14.24.28314/bin/Hostx64/x64/cl.exe",
      "cStandard": "c11",
      "cppStandard": "c++17",
      "intelliSenseMode": "msvc-x64"
    }
  ],
  "version": 4
}

Sie müssen nur das Feld Include path (Include-Pfad) erweitern, wenn Ihr Programm Header-Dateien enthält, die sich nicht in Ihrem Workspace oder im Standard-Bibliotheks-Pfad befinden.

Compilerpfad

Die Einstellung compilerPath ist eine wichtige Einstellung in Ihrer Konfiguration. Die Erweiterung verwendet sie, um den Pfad zu den C++-Standardbibliotheks-Header-Dateien abzuleiten. Wenn die Erweiterung weiß, wo diese Dateien zu finden sind, kann sie nützliche Funktionen wie intelligente Vervollständigungen und die Navigation über Zu Definition springen bereitstellen.

Die C/C++-Erweiterung versucht, compilerPath mit dem Standard-Compiler-Speicherort zu füllen, basierend auf dem, was sie auf Ihrem System findet. Die Erweiterung sucht an mehreren gängigen Compiler-Speicherorten.

Die Suchreihenfolge für compilerPath lautet:

Zuerst wird der Microsoft Visual C++-Compiler geprüftOpe
Dann wird nach g++ unter Windows Subsystem für Linux (WSL) gesucht
Dann g++ für Mingw-w64.

Wenn Sie g++ oder WSL installiert haben, müssen Sie möglicherweise compilerPath ändern, um den bevorzugten Compiler für Ihr Projekt anzugeben. Für Microsoft C++ sollte der Pfad je nach installierter Version etwa so aussehen: "C:/Program Files (x86)/Microsoft Visual Studio/2017/BuildTools/VC/Tools/MSVC/14.16.27023/bin/Hostx64/x64/cl.exe".

Ihre C++-Konfiguration wiederverwenden

VS Code ist nun für die Verwendung des Microsoft C++-Compilers konfiguriert. Die Konfiguration gilt für den aktuellen Workspace. Um die Konfiguration wiederzuverwenden, kopieren Sie einfach die JSON-Dateien in einen .vscode-Ordner in einem neuen Projektordner (Workspace) und ändern Sie die Namen der Quellcode-Datei(en) und der ausführbaren Datei nach Bedarf.

VS Code außerhalb der Eingabeaufforderung für Entwickler ausführen

Unter bestimmten Umständen ist es nicht möglich, VS Code über die Eingabeaufforderung für Entwickler für Visual Studio auszuführen (z. B. in Remote-Entwicklungsszenarien über SSH). In diesem Fall können Sie die Initialisierung der Eingabeaufforderung für Entwickler für Visual Studio während des Builds mit der folgenden tasks.json-Konfiguration automatisieren:

{
  "version": "2.0.0",
  "windows": {
    "options": {
      "shell": {
        "executable": "cmd.exe",
        "args": [
          "/C",
          // The path to VsDevCmd.bat depends on the version of Visual Studio you have installed.
          "\"C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/Tools/VsDevCmd.bat\"",
          "&&"
        ]
      }
    }
  },
  "tasks": [
    {
      "type": "shell",
      "label": "cl.exe build active file",
      "command": "cl.exe",
      "args": [
        "/Zi",
        "/EHsc",
        "/Fe:",
        "${fileDirname}\\${fileBasenameNoExtension}.exe",
        "${file}"
      ],
      "problemMatcher": ["$msCompile"],
      "group": {
        "kind": "build",
        "isDefault": true
      }
    }
  ]
}

Hinweis: Der Pfad zu VsDevCmd.bat kann je nach Visual Studio-Version oder Installationspfad variieren. Sie finden den Pfad zu VsDevCmd.bat, indem Sie eine Eingabeaufforderung öffnen und dir "\VsDevCmd*" /s ausführen.

Fehlerbehebung

Der Begriff 'cl.exe' wird nicht erkannt

Wenn Sie die Fehlermeldung "Der Begriff 'cl.exe' wird nicht als Name eines Cmdlets, einer Funktion, einer Skriptdatei oder eines ausführbaren Programms erkannt." sehen, bedeutet dies normalerweise, dass Sie VS Code außerhalb einer Eingabeaufforderung für Entwickler für Visual Studio ausführen und VS Code den Pfad zum cl.exe-Compiler nicht kennt.

VS Code muss entweder von der Eingabeaufforderung für Entwickler für Visual Studio gestartet werden, oder die Aufgabe muss so konfiguriert sein, dass sie außerhalb einer Eingabeaufforderung für Entwickler ausgeführt wird.

Sie können jederzeit überprüfen, ob Sie VS Code im Kontext der Eingabeaufforderung für Entwickler ausführen, indem Sie ein neues Terminal öffnen (⌃⇧` (Windows, Linux Ctrl+Shift+`)) und 'cl' eingeben, um zu überprüfen, ob cl.exe für VS Code verfügbar ist.

fatal error C1034: assert.h: kein Include-Pfad gesetzt

In diesem Fall ist cl.exe über die Umgebungsvariable PATH für VS Code verfügbar, aber VS Code muss entweder von der Eingabeaufforderung für Entwickler für Visual Studio gestartet werden oder so konfiguriert sein, dass es außerhalb der Eingabeaufforderung für Entwickler ausgeführt wird. Andernfalls hat cl.exe keinen Zugriff auf wichtige Umgebungsvariablen wie INCLUDE.

Nächste Schritte

Erkunden Sie den VS Code Benutzerhandbuch.
Überprüfen Sie die Übersicht über die C++-Erweiterung.
Erstellen Sie einen neuen Workspace, kopieren Sie Ihre .vscode-JSON-Dateien hinein, passen Sie die erforderlichen Einstellungen für den neuen Workspace-Pfad, den Programmnamen usw. an und beginnen Sie mit dem Codieren!

3/7/2023