Konfigurieren eines CMake-Projekts für Linux in Visual Studio

Artikel
06/16/2023

Die Unterstützung für Linux ist in Visual Studio 2017 und höher verfügbar. Wenn die Dokumentation für diese Versionen angezeigt werden soll, legen Sie die Dropdownliste Version über dem Inhaltsverzeichnis auf Visual Studio 2017 oder Visual Studio 2019 fest.

In diesem Thema wird beschrieben, wie eine Linux-Konfiguration einem CMake-Projekt hinzugefügt wird, das entweder auf ein Linux-Remotesystem oder ein Windows-Subsystem für Linux (WSL) abzielt. Dabei wird die Reihe fortgesetzt, die mit Erstellen eines CMake-Projekts für Linux in Visual Studio begonnen hat. Wenn Sie stattdessen MSBuild verwenden, finden Sie weitere Informationen unter Konfigurieren eines MSBuild-Projekts für Linux in Visual Studio.

Hinzufügen einer Linux-Konfiguration

Eine Konfiguration dient dazu, mit dem gleichen Quellcode auf verschiedene Plattformen (Windows, WSL, Remotesystem) abzuzielen. Eine Konfiguration dient auch zum Festlegen Ihrer Compiler, zum Übergeben von Umgebungsvariablen und zum Anpassen des Aufrufs von CMake. Die Datei CMakeSettings.json gibt alle unter Anpassen von CMake-Buildeinstellungen aufgeführten Eigenschaften sowie weitere Eigenschaften an, die die Buildeinstellungen auf dem Linux-Remotecomputer steuern.

Wenn Sie die Standard-CMake-Einstellungen in Visual Studio 2017 ändern möchten, klicken Sie im Hauptmenü auf CMake>Change CMake Settings>CMakeLists.txt (CMake > CMake-Einstellungen ändern > CMakeLists.txt). Alternativ können Sie auch mit der rechten Maustaste im Projektmappen-Explorer auf CMakeLists.txt klicken und die Option CMake-Einstellungen ändern auswählen. Visual Studio erstellt dann eine neue CMakeSettings.json-Datei im Stammordner des Projekts. Um Änderungen vorzunehmen, öffnen Sie die Datei, und ändern Sie sie direkt. Weitere Informationen finden Sie unter Customize CMake settings (Anpassen von CMake-Einstellungen).

Die Standardkonfiguration für Linux-Debuggen in Visual Studio 2017 (und Visual Studio 2019, Version 16.0) sieht wie folgt aus:

{
  "configurations": [
    {
      "name": "Linux-Debug",
      "generator": "Unix Makefiles",
      "remoteMachineName": "${defaultRemoteMachineName}",
      "configurationType": "Debug",
      "remoteCMakeListsRoot": "/var/tmp/src/${workspaceHash}/${name}",
      "cmakeExecutable": "/usr/local/bin/cmake",
      "buildRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\build\\${name}",
      "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\install\\${name}",
      "remoteBuildRoot": "/var/tmp/build/${workspaceHash}/build/${name}",
      "remoteInstallRoot": "/var/tmp/build/${workspaceHash}/install/${name}",
      "remoteCopySources": true,
      "remoteCopySourcesOutputVerbosity": "Normal",
      "remoteCopySourcesConcurrentCopies": "10",
      "remoteCopySourcesMethod": "rsync",
      "remoteCopySourcesExclusionList": [
        ".vs",
        ".git"
      ],
      "rsyncCommandArgs": "-t --delete --delete-excluded",
      "remoteCopyBuildOutput": false,
      "cmakeCommandArgs": "",
      "buildCommandArgs": "",
      "ctestCommandArgs": "",
      "inheritEnvironments": [
        "linux_x64"
      ]
    }
  ]
}

Um die CMake-Standardeinstellungen in Visual Studio 2019 oder höher zu ändern, öffnen Sie auf der Hauptsymbolleiste die Dropdownliste Konfiguration, und wählen Sie Konfiguration verwalten aus.

Screenshot der Option „Konfigurationen verwalten“ in CMake, die in der Dropdownliste „Konfiguration“ hervorgehoben ist.

Durch diesen Befehl wird der Editor für CMake-Einstellungen geöffnet, den Sie zum Bearbeiten der Datei CMakeSettings.json im Stammprojektordner verwenden können. Sie können die Datei auch mit dem JSON-Editor öffnen, indem Sie auf die Schaltfläche JSON bearbeiten in der oberen rechten Ecke des Dialogfelds CMake-Einstellungen klicken. Weitere Informationen finden Sie unter Anpassen von CMake-Einstellungen.

Die Standardkonfiguration für das Linux-Debuggen in Visual Studio 2019, Version 16.1 sieht wie folgt aus:

{
  "configurations": [
    {
      "name": "Linux-GCC-Debug",
      "generator": "Ninja",
      "configurationType": "Debug",
      "cmakeExecutable": "cmake",
      "remoteCopySourcesExclusionList": [ ".vs", ".git", "out" ],
      "cmakeCommandArgs": "",
      "buildCommandArgs": "",
      "ctestCommandArgs": "",
      "inheritEnvironments": [ "linux_x64" ],
      "remoteMachineName": "${defaultRemoteMachineName}",
      "remoteCMakeListsRoot": "$HOME/.vs/${projectDirName}/${workspaceHash}/src",
      "remoteBuildRoot": "$HOME/.vs/${projectDirName}/${workspaceHash}/out/build/${name}",
      "remoteInstallRoot": "$HOME/.vs/${projectDirName}/${workspaceHash}/out/install/${name}",
      "remoteCopySources": true,
      "rsyncCommandArgs": "-t --delete --delete-excluded",
      "remoteCopyBuildOutput": false,
      "remoteCopySourcesMethod": "rsync",
      "variables": []
    }
  ]
}

Ab Visual Studio 2019, Version 16.6 ist Ninja der Standardgenerator für Konfigurationen, die auf ein Remotesystem oder das WSL abzielen (im Gegensatz zu Unix Makefiles). Weitere Informationen finden Sie in diesem Beitrag im C++-Teamblog.

Weitere Informationen zu diesen Einstellungen finden Sie in der Referenz zu CMakeSettings.json.

Beim Erstellen eines Builds:

Für Remoteziele wählt Visual Studio standardmäßig das erste Remotesystem in der Liste unter Extras>Optionen>Plattformübergreifend>Verbindungs-Manager aus.
Wenn keine Remoteverbindungen gefunden werden, werden Sie aufgefordert, eine Remoteverbindung zu erstellen. Weitere Informationen finden Sie unter Herstellen einer Verbindung mit Ihrem Linux-Remotecomputer.

Auswählen eines Linux-Ziels

Wenn Sie einen CMake-Projektordner öffnen, analysiert Visual Studio die Datei CMakeLists.txt und gibt das Windows-Ziel x86-Debug an. Um ein Linux-Remotesystem als Ziel anzugeben, ändern Sie die Projekteinstellungen basierend auf Ihrem Linux-Compiler. Wenn Sie beispielsweise GCC unter Linux verwenden und mit Debuginformationen kompilieren, wählen Sie Folgendes aus: Linux-GCC-Debug oder Linux-GCC-Release.

Wenn Sie ein Linux-Remoteziel angeben, wird Ihre Quelle in das Remotesystem kopiert.

Wenn Sie ein Ziel ausgewählt haben, wird CMake zum Generieren des CMake-Caches für Ihr Projekt automatisch auf dem Linux-System ausgeführt:

Screenshot von Visual Studio mit der Ausgabe nach dem Generieren eines CMake-Caches unter Linux

Abzielen auf das Windows-Subsystem für Linux

Wenn Sie auf das Windows-Subsystem für Linux (WSL) abzielen, müssen Sie keine Remoteverbindung hinzufügen.

Um das WSL als Ziel anzugeben, wählen Sie in der Hauptsymbolleiste im Dropdownmenü „Konfiguration“ die Option Konfigurationen verwalten aus:

CMake-Dropdownmenü „Konfigurationen“ mit ausgewählter Option „Konfigurationen verwalten“

Das Fenster CMakeSettings.json wird angezeigt.

CMake-Dialogfeld „Einstellungen“ mit hervorgehobener Plusschaltfläche, mit der die ausgewählte Konfiguration hinzugefügt wird (in diesem Fall „Linux-GCC-debug“)

Klicken Sie auf Konfiguration hinzufügen (die grüne Schaltfläche mit dem Pluszeichen), und wählen Sie Linux-GCC-Debug oder Linux-GCC-Release aus, wenn Sie GCC verwenden. Wenn Sie das Clang/LLVM-Toolset verwenden, wählen Sie die Clang-Varianten aus. Klicken Sie auf Auswählen, und drücken Sie dann STRG+S, um die Konfiguration zu speichern.

Visual Studio 2019, Version 16.1 Wenn Sie auf die WSL zielen, muss Visual Studio keine Quelldateien kopieren und zwei synchrone Kopien Ihrer Buildstruktur pflegen, da der Compiler unter Linux direkten Zugriff auf Ihre Quelldateien im eingebundenen Windows-Dateisystem hat.

IntelliSense

Damit IntelliSense für C++ präzise arbeitet, ist ein Zugriff auf die C++-Header erforderlich, auf die Ihre C++-Quelldateien verweisen. Visual Studio verwendet automatisch die Header, auf die von einem CMake-Projekt von Linux zu Windows verwiesen wird, um ein originalgetreues IntelliSense-Erlebnis zu bieten. Weitere Informationen finden Sie unter IntelliSense für Remoteheader (Visual Studio 2017-Version 15.7 und höher).

Einstellung des Gebietsschemas

Visual Studio-Spracheinstellungen werden nicht an Linux-Ziele weitergegeben, da Visual Studio installierte Pakete nicht verwaltet oder konfiguriert. Nachrichten, die im Ausgabefenster angezeigt werden (z. B. Buildfehler), werden mit der Sprache und dem Gebietsschema des Linux-Ziels angezeigt. Sie müssen Ihre Linux-Ziele für das gewünschte Gebietsschema konfigurieren.

Weitere Einstellungen

Mithilfe dieser Einstellungen können Sie Befehle vor und nach dem Build und vor der CMake-Generierung auf dem Linux-System ausführen. Die Werte können ein beliebiger Befehl sein, der auf dem Remotesystem gültig ist. Die Ausgabe wird wieder zurück an Visual Studio geleitet.

{
      "remotePrebuildCommand": "",
      "remotePreGenerateCommand": "",
      "remotePostbuildCommand": "",
}

Nächste Schritte

Konfigurieren von CMake-Debugsitzungen

Weitere Informationen

Arbeiten mit Projekteigenschaften
Anpassen von CMake-Buildeinstellungen
CMake predefined configuration reference (Referenz für vordefinierte CMake-Konfigurationen)

Freigeben über