GCC mit MinGW verwenden

In diesem Tutorial konfigurieren Sie Visual Studio Code so, dass der GCC C++-Compiler (g++) und der GDB-Debugger von mingw-w64 verwendet werden, um Programme zu erstellen, die unter Windows ausgeführt werden. Nach der Konfiguration von VS Code kompilieren, ausführen und debuggen Sie ein "Hello World"-Programm.

Dieses Tutorial lehrt Sie nicht GCC, GDB, mingw-w64 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 die folgenden Schritte ausführen

1. Installieren Sie Visual Studio Code.

2. Installieren Sie die C/C++-Erweiterung für VS Code. Sie können die C/C++-Erweiterung installieren, indem Sie in der Erweiterungsansicht nach "C++" suchen (⇧⌘X (Windows, Linux Ctrl+Shift+X)).

   

Installation der MinGW-w64-Toolchain

Holen Sie sich die neueste Version von MinGW-w64 über MSYS2, das aktuelle native Builds von GCC, MinGW-w64 und anderen nützlichen C++-Tools und Bibliotheken bereitstellt. Dies stellt Ihnen die notwendigen Werkzeuge zur Verfügung, um Ihren Code zu kompilieren, zu debuggen und für die Arbeit mit IntelliSense zu konfigurieren.

Um die MinGW-w64-Toolchain zu installieren, schauen Sie sich dieses Video an oder folgen Sie den nachstehenden Schritten

1. Sie können den neuesten Installer von der MSYS2-Seite herunterladen oder diesen direkten Link zum Installer verwenden.

2. Führen Sie den Installer aus und folgen Sie den Schritten des Installationsassistenten. Beachten Sie, dass MSYS2 64-Bit-Windows 8.1 oder neuer erfordert.

3. Wählen Sie im Assistenten Ihren gewünschten Installationsordner aus. Notieren Sie sich dieses Verzeichnis für später. In den meisten Fällen ist das empfohlene Verzeichnis akzeptabel. Das Gleiche gilt, wenn Sie zur Festlegung der Startmenü-Verknüpfungen gelangen. Stellen Sie nach Abschluss sicher, dass das Kontrollkästchen MSYS2 jetzt ausführen aktiviert ist, und wählen Sie Fertig stellen. Dies öffnet ein MSYS2-Terminalfenster für Sie.

4. Installieren Sie in diesem Terminal die MinGW-w64-Toolchain, indem Sie den folgenden Befehl ausführen

   pacman -S --needed base-devel mingw-w64-ucrt-x86_64-toolchain
   

5. Akzeptieren Sie die Standardanzahl von Paketen in der toolchain-Gruppe, indem Sie Enter drücken.

   

6. Geben Sie Y ein, wenn Sie gefragt werden, ob Sie mit der Installation fortfahren möchten.

7. Fügen Sie den Pfad Ihres MinGW-w64 bin-Ordners zur Windows PATH-Umgebungsvariable hinzu, indem Sie die folgenden Schritte ausführen

   1. Geben Sie in der Windows-Suchleiste Einstellungen ein, um Ihre Windows-Einstellungen zu öffnen.
   2. Suchen Sie nach Umgebungsvariablen für Ihr Konto bearbeiten.
   3. Wählen Sie in Ihren Benutzervariablen die Variable Path aus und wählen Sie dann Bearbeiten.
   4. Wählen Sie Neu und fügen Sie den MinGW-w64-Zielordner, den Sie während des Installationsvorgangs notiert haben, zur Liste hinzu. Wenn Sie die oben genannten Standardeinstellungen verwendet haben, ist dies der Pfad: C:\msys64\ucrt64\bin.
   5. Wählen Sie OK und dann im Fenster Umgebungsvariablen erneut OK, um die PATH-Umgebungsvariable zu aktualisieren. Sie müssen alle Konsolenfenster neu öffnen, damit die aktualisierte PATH-Umgebungsvariable verfügbar ist.

Überprüfen Sie Ihre MinGW-Installation

Um zu überprüfen, ob Ihre MinGW-w64-Tools korrekt installiert und verfügbar sind, öffnen Sie eine neue Eingabeaufforderung und geben Sie ein

gcc --version
g++ --version
gdb --version

Sie sollten die Ausgabe sehen, die die Versionen von GCC, g++ und GDB angibt, die Sie installiert haben. Wenn dies nicht der Fall ist

1. Stellen Sie sicher, dass Ihr PATH-Eintrag mit dem Speicherort des MinGW-w64-Binärprogramms übereinstimmt, an dem die Toolchain installiert wurde. Wenn die Compiler nicht unter diesem PATH-Eintrag vorhanden sind, stellen Sie sicher, dass Sie die vorherigen Anweisungen befolgt haben.
2. Wenn gcc die korrekte Ausgabe hat, aber gdb nicht, müssen Sie die fehlenden Pakete aus der MinGW-w64-Toolchain installieren.
   • Wenn Sie beim Kompilieren die Meldung "Der Wert von miDebuggerPath ist ungültig." erhalten, kann eine Ursache darin liegen, dass Ihnen das Paket mingw-w64-gdb fehlt.

Eine "Hello World"-Anwendung erstellen

Zuerst richten wir ein Projekt ein.

1. Starten Sie eine Windows-Eingabeaufforderung (Geben Sie Windows-Eingabeaufforderung in die Windows-Suchleiste ein).
2. Führen Sie die folgenden Befehle aus. Diese erstellen einen leeren Ordner namens projects, in dem Sie alle Ihre VS Code-Projekte ablegen können. Dort erstellen die nächsten Befehle einen Unterordner namens helloworld und wechseln dorthin. Von dort aus öffnen Sie helloworld direkt in VS Code.

mkdir projects
cd projects
mkdir helloworld
cd helloworld
code .

Der Befehl "code ." öffnet VS Code im aktuellen Arbeitsordner, der zu Ihrem "Arbeitsbereich" wird. Akzeptieren Sie den Dialog Workspace Trust, indem Sie Ja, ich vertraue den Autoren auswählen, da dies ein von Ihnen erstellter Ordner ist.

Während Sie durch das Tutorial gehen, sehen Sie drei Dateien, die in einem .vscode-Ordner im Arbeitsbereich erstellt werden

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

Eine "Hello World"-Quelldatei 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

Sie können auch die automatische Speicherung aktivieren, um Ihre Dateänderungen automatisch zu speichern, indem Sie Datei > Automatisch speichern auswählen. Weitere Informationen zu den anderen Ansichten finden Sie in der Benutzeroberflächen-Dokumentation 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 Werkzeug, das Ihnen hilft, schneller und effizienter zu programmieren, indem es Funktionen zur Codebearbeitung wie Codevervollständigung, Parameterinformationen, Schnelleinfachungen und Mitgliedslisten 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 Vervollständigungsliste empfohlener Memberfunktionen, die aufgerufen werden können, alle von IntelliSense generiert

Sie können die Tabulatortaste drücken, um ein ausgewähltes Mitglied einzufügen. Wenn Sie dann eine öffnende Klammer hinzufügen, zeigt IntelliSense Informationen darüber an, welche Argumente erforderlich sind.

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 gcc.exe verwenden zur Konfiguration aus. Weitere Informationen finden Sie in der Dokumentation zur IntelliSense-Konfiguration.

helloworld.cpp ausführen

Denken Sie daran, dass die C++-Erweiterung den C++-Compiler verwendet, den Sie auf Ihrem Computer installiert haben, um Ihr Programm zu erstellen. Stellen Sie sicher, dass Sie den Schritt "Installation der MinGW-w64-Toolchain" abgeschlossen 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 C/C++: g++.exe Datei erstellen und debuggen aus der Liste der auf Ihrem System erkannten Compiler 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.

   

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 eine tasks.json-Datei, die Sie im .vscode-Ordner Ihres Projekts finden. tasks.json speichert Ihre Build-Konfigurationen.

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

{
  "tasks": [
    {
      "type": "cppbuild",
      "label": "C/C++: g++.exe build active file",
      "command": "C:\\msys64\\ucrt64\\bin\\g++.exe",
      "args": [
        "-fdiagnostics-color=always",
        "-g",
        "${file}",
        "-o",
        "${fileDirname}\\${fileBasenameNoExtension}.exe"
      ],
      "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 g++.

Das Array args gibt die an g++ übergebenen Befehlszeilenargumente an. Diese Argumente sind in dieser Datei in der vom Compiler erwarteten Reihenfolge aufgeführt.

Diese Aufgabe weist g++ an, die aktive Datei (${file}) zu kompilieren und eine Ausgabedatei (-o-Schalter) im aktuellen Verzeichnis (${fileDirname}) mit demselben Namen wie die aktive Datei, aber mit der Erweiterung .exe (${fileBasenameNoExtension}.exe) zu erstellen. Für uns ergibt dies helloworld.exe.

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. Es wird dringend empfohlen, diesen Wert umzubenennen, um ihn von ähnlichen Aufgaben zu unterscheiden.

Der Wert problemMatcher wählt den Ausgabeparser aus, der zum Auffinden von Fehlern und Warnungen in der Compiler-Ausgabe verwendet wird. Für GCC erzielen Sie die besten Ergebnisse, wenn Sie den $gcc-Problem-Matcher verwenden.

Von nun an liest die Wiedergabetaste aus tasks.json, um zu ermitteln, wie Ihr Programm erstellt und ausgeführt wird. Sie können mehrere Build-Aufgaben in tasks.json definieren, und welche Aufgabe als Standard gekennzeichnet ist, wird von der Wiedergabetaste verwendet. Falls Sie den Standardcompiler ändern müssen, können Sie Aufgaben: Standard-Build-Aufgabe konfigurieren in der Befehlspalette ausführen. Alternativ können Sie die Datei tasks.json ändern und dieses Segment entfernen, indem Sie diesen Segment ersetzen

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

durch dieses:

    "group": "build",

Ändern von tasks.json

Ab dem 3. November 2024 hat MSYS2 die Unterstützung für Wildcards für mingw-w64 standardmäßig deaktiviert. Diese Änderung wirkt sich darauf aus, wie Wildcards wie "*.cpp" in Build-Befehlen verarbeitet werden. Um mehrere C++-Dateien in Ihrer tasks.json zu kompilieren, müssen Sie die Dateien explizit auflisten, ein Build-System wie make oder cmake verwenden oder die folgenden Workarounds implementieren: https://www.msys2.org/docs/c/#expanding-wildcard-arguments.

Wenn Sie zuvor "${workspaceFolder}/*.cpp" verwendet haben, um alle .cpp-Dateien im aktuellen Ordner zu kompilieren, funktioniert dies nicht mehr direkt. Stattdessen können Sie die Dateien manuell auflisten oder ein Build-Skript definieren.

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++ Datei erstellen und debuggen aus der Liste der auf Ihrem System erkannten Compiler aus (Sie werden nur beim ersten Ausführen oder Debuggen von helloworld.cpp aufgefordert, einen Compiler auszuwählen).

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

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 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.

1. Wählen Sie das Symbol Schritt über im Debugging-Bedienfeld aus.

   

   Dies verschiebt die Programmausführung zur ersten Zeile der for-Schleife und überspringt alle internen Funktionsaufrufe innerhalb der vector- und string-Klassen, die beim Erstellen und Initialisieren der msg-Variablen aufgerufen werden. 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 und daher zu diesem Zeitpunkt nichts zu lesen ist. Der Inhalt von msg ist jedoch sichtbar, da diese Anweisung abgeschlossen ist.

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 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.)

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 integrierten Terminal sehen, zusammen mit einigen anderen Diagnoseinformationen, die von GDB ausgegeben werden.

   

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 auf die Variable setzen.

1. Setzen Sie den Einfügepunkt in die Schleife. Wählen Sie im Fenster Watch das Pluszeichen aus und geben Sie im Textfeld word ein, den Namen der Schleifenvariable. Betrachten Sie nun das Watch-Fenster, während Sie die Schleife durchlaufen.

   

2. 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.

3. 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.

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

VS Code erstellt eine launch.json-Datei im .vscode-Ordner`, die ungefähr so aussieht

{
  "configurations": [
    {
      "name": "C/C++: g++.exe build and debug active file",
      "type": "cppdbg",
      "request": "launch",
      "program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
      "args": [],
      "stopAtEntry": false,
      "cwd": "${fileDirname}",
      "environment": [],
      "externalConsole": false,
      "MIMode": "gdb",
      "miDebuggerPath": "C:\\msys64\\ucrt64\\bin\\gdb.exe",
      "setupCommands": [
        {
          "description": "Enable pretty-printing for gdb",
          "text": "-enable-pretty-printing",
          "ignoreFailures": true
        },
        {
          "description": "Set Disassembly Flavor to Intel",
          "text": "-gdb-set disassembly-flavor intel",
          "ignoreFailures": true
        }
      ],
      "preLaunchTask": "C/C++: g++.exe build active file"
    }
  ],
  "version": "2.0.0"
}

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

Hinzufügen von zusätzlichen C/C++-Einstellungen

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.

Hier haben wir den Konfigurationsnamen in GCC geändert, das Dropdown-Menü Compilerpfad auf den g++-Compiler eingestellt und den IntelliSense-Modus an den Compiler angepasst (gcc-x64).

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

{
  "configurations": [
    {
      "name": "GCC",
      "includePath": ["${workspaceFolder}/**"],
      "defines": ["_DEBUG", "UNICODE", "_UNICODE"],
      "windowsSdkVersion": "10.0.22000.0",
      "compilerPath": "C:/msys64/mingw64/bin/g++.exe",
      "cStandard": "c17",
      "cppStandard": "c++17",
      "intelliSenseMode": "windows-gcc-x64"
    }
  ],
  "version": 4
}

Sie müssen nur zum Array-Eintrag Include-Pfad hinzufügen, wenn Ihr Programm Header-Dateien enthält, die sich nicht in Ihrem Arbeitsbereich oder im Standard-Bibliotheks-Pfad befinden. Es wird dringend empfohlen, den System-Include-Pfad nicht zur includePath-Einstellung für Compiler hinzuzufügen, die wir unterstützen.

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 Zur Definition springen bereitstellen.

Die C/C++-Erweiterung versucht, compilerPath mit einem Standardcompiler zu füllen, basierend auf dem, was sie auf Ihrem System findet. Die Erweiterung sucht an mehreren gängigen Compiler-Speicherorten, wählt aber nur automatisch einen aus, der sich entweder in einem der "Programme"-Ordner befindet oder dessen Pfad in der PATH-Umgebungsvariable aufgeführt ist. Wenn der Microsoft Visual C++-Compiler gefunden werden kann, wird er ausgewählt, andernfalls wird eine Version von gcc, g++ oder clang ausgewählt.

Wenn Sie mehr als einen Compiler installiert haben, müssen Sie möglicherweise compilerPath ändern, um den bevorzugten Compiler für Ihr Projekt anzugeben. Sie können auch den Befehl C/C++: IntelliSense-Konfiguration auswählen... in der Befehlspalette verwenden, um einen der von der Erweiterung erkannten Compiler auszuwählen.

Fehlerbehebung

MSYS2 ist installiert, aber g++ und gdb werden immer noch nicht gefunden

Sie müssen die Schritte auf der MSYS2-Website befolgen, um die MSYS CLI zu verwenden, um die vollständige MinGW-w64-Toolchain (pacman -S --needed base-devel mingw-w64-ucrt-x86_64-toolchain) sowie alle erforderlichen Voraussetzungen zu installieren. Die Toolchain umfasst g++ und gdb.

Als Windows-Benutzer erhalte ich bei der Ausführung des pacman-Befehls einen Fehler

UCRT auf Windows-Rechnern ist nur in Windows 10 oder neuer enthalten. Wenn Sie eine andere Windows-Version verwenden, führen Sie den folgenden Befehl aus, der UCRT nicht verwendet

pacman -S --needed base-devel mingw-w64-x86_64-toolchain

Beim Hinzufügen des MinGW-w64-Zielordners zu Ihrer Liste von Umgebungsvariablen ist der Standardpfad dann: C:\msys64\mingw64\bin.

MinGW 32-Bit

Wenn Sie eine 32-Bit-Version der MinGW-Toolchain benötigen, konsultieren Sie den Abschnitt Herunterladen auf der MSYS2-Wiki. Er enthält Links zu Installationsoptionen für 32-Bit und 64-Bit.

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 .vscode-JSON-Dateien dorthin, passen Sie die notwendigen Einstellungen für den neuen Arbeitsbereichspfad, den Programmnamen usw. an und beginnen Sie mit dem Programmieren!