Freigeben über


CMake-Projekte in Visual Studio

CMake ist ein plattformübergreifendes Open Source-Tool, das zum Definieren von Buildprozessen verwendet wird, die auf mehreren Plattformen ausgeführt werden. In diesem Artikel wird davon ausgegangen, dass Sie mit CMake vertraut sind. Weitere Informationen zu CMake finden Sie in der CMake-Dokumentation. Das CMake-Tutorial ist ein guter Ausgangspunkt, um mehr zu erfahren.

Hinweis

CMake wurde in den letzten Releases immer mehr in Visual Studio integriert. Um die Dokumentation für Ihre bevorzugte Version von Visual Studio anzuzeigen, verwenden Sie das Auswahlsteuerelement Version. Es befindet sich am Anfang des Inhaltsverzeichnisses auf dieser Seite.

Die native Unterstützung von Visual Studio für CMake ermöglicht das Bearbeiten, Kompilieren und Debuggen von CMake-Projekten unter Windows, dem Windows-Subsystem für Linux (WSL) und Remotesystemen aus derselben Instanz von Visual Studio. CMake-Projektdateien (z. B. CMakeLists.txt) werden direkt von Visual Studio für IntelliSense- und Browserzwecke verwendet. cmake.exe wird direkt von Visual Studio für CMake-Konfiguration und -Build aufgerufen.

Installation

Die Komponente C++-CMake-Tools für Windows wird als Teil der Workloads Desktopentwicklung mit C++ und Linux Entwicklung mit C++ installiert. Sowohl CMake-Tools für Windows und Linux-Entwicklung mit C++ sind für die plattformübergreifende CMake-Entwicklung erforderlich.

Screenshot des Visual Studio-Installers

Im Installationsprogramm ist das Dropdownmenü „Desktopentwicklung mit C++“ ausgewählt und „C++ CMake Tools für Windows“ ist ausgewählt.

Weitere Informationen finden Sie unter Install the C++ Linux workload in Visual Studio (Installieren der C++-Workload unter Linux in Visual Studio).

IDE-Integration

Wenn Sie einen Ordner öffnen, der eine CMakeLists.txt-Datei enthält, geschieht Folgendes:

Screenshot des ersten Dialogfelds, das beim Starten von Visual Studio geöffnet wird.

Das Dialogfeld bietet folgende Optionen: Ein Repository klonen, ein Projekt oder eine Projektmappe öffnen, einen lokalen Ordner öffnen oder ein neues Projekt erstellen. Im Screenshot wird das Öffnen eines lokalen Ordners angezeigt.

  • Visual Studio fügt ein CMake-Element zum Menü Projekt mit Befehlen zum Anzeigen und Bearbeiten von CMake-Skripts hinzu.

  • Im Projektmappen-Explorer werden die Ordnerstruktur und die Dateien angezeigt.

  • Visual Studio führt CMake aus und generiert eine CMake-Cachedatei (CMakeCache.txt) für die Standardkonfiguration. Die CMake-Befehlszeile wird im Ausgabefenster zusammen mit weiteren Ausgaben von CMake angezeigt.

  • Im Hintergrund beginnt Visual Studio damit, die Quelldateien zu indizieren, um IntelliSense, das Durchsuchen von Informationen, das Refactoring und vieles mehr zu ermöglichen. Während Sie arbeiten, überwacht Visual Studio die Änderungen im Editor und auf dem Datenträger, damit der Index mit den Quellen synchron ist.

Hinweis

Ab Visual Studio 2022 Version 17.1 Preview 2 werden Sie gefragt, ob Sie die CMake-Integration aktivieren möchten, wenn sich Ihre oberste CMakeLists.txt in einem Unterordner und nicht im Stammverzeichnis des Arbeitsbereichs befindet. Weitere Informationen finden Sie unter Partielle Aktivierung von CMake.

Sobald die CMake-Cachegenerierung erfolgreich war, können Sie Ihre Projekte logisch nach Zielen organisiert anzeigen. Wählen Sie die Schaltfläche Ansicht auswählen in der Symbolleiste des Projektmappen-Explorers aus. Wählen Sie in der Liste im Projektmappen-Explorer – Ansichten die CMake Zielansicht aus, und drücken Sie die Eingabetaste, um die Zielansicht zu öffnen:

Screenshot des Fensters „Projektmappen-Explorer – Ansichten“. Die Ordneransicht ist geöffnet. Die Option „CMake Zielansicht“ ist hervorgehoben.

Klicken Sie oben im Projektmappen-Explorer auf Alle Dateien anzeigen, um die von CMake generierten Ausgaben in den Ordnern out/build/<config> anzuzeigen.

Verwenden Sie die Datei CMakeLists.txt in jedem Projektordner wie in jedem anderen CMake-Projekt. Sie können Quelldateien angeben, Bibliotheken suchen, Compiler- und Linkeroptionen festlegen und weitere Informationen im Zusammenhang mit dem Buildsystem angeben. Weitere Informationen zu CMake-Sprachdiensten, die von Visual Studio bereitgestellt werden, finden Sie unter Bearbeiten von CMakeLists.txt-Dateien.

Visual Studio verwendet eine CMake-Konfigurationsdatei zum Generieren und Kompilieren von CMake-Caches. Weitere Informationen finden Sie unter Konfigurieren von CMake-Projekten und Kompilieren von CMake-Projekten.

Um beim Debuggen Argumente an eine ausführbare Datei zu übergeben, können Sie eine andere Datei mit dem Namen launch.vs.json verwenden. Weitere Informationen zum Debuggen plattformübergreifender CMake-Projekte in Visual Studio finden Sie unter Debuggen von CMake-Projekten.

Die meisten Visual Studio- und C++-Sprachfeatures werden von CMake-Projekte in Visual Studio unterstützt. Beispiele:

Hinweis

Für andere Arten von „Ordner öffnen“-Projekten wird die zusätzliche JSON-Datei CppProperties.json verwendet. Diese Datei ist für CMake-Projekte nicht relevant.

Konfigurieren von CMake-Projekten

Der CMake-Konfigurationsschritt generiert das Projektbuildsystem. Dies entspricht dem Aufrufen von cmake.exe über die Befehlszeile. Weitere Informationen zum CMake-Konfigurationsschritt finden Sie in der CMake-Dokumentation.

Visual Studio verwendet eine CMake-Konfigurationsdatei, um CMake-Generierung und -Build zu steuern. CMakePresets.json wird von Visual Studio 2019, Version 16.10 oder höher unterstützt und ist die empfohlene CMake-Konfigurationsdatei. CMakePresets.json wird direkt von CMake unterstützt und kann dazu verwendet werden, CMake-Generierung und -Build aus Visual Studio, aus VS Code, in einer Continuous Integration-Pipeline und von der Befehlszeile unter Windows, Linux und Mac zu steuern. Weitere Informationen zu CMakePresets.json finden Sie unter Konfigurieren und Kompilieren mit CMake-Voreinstellungen. CMakeSettings.json ist für Kundinnen und Kunden verfügbar, die eine frühere Version von Visual Studio verwenden. Weitere Informationen über CMakeSettings.json finden Sie unter Anpassen von CMake-Buildeinstellungen.

Wenn Sie erhebliche Änderungen an Ihrer CMake-Konfigurationsdatei oder einer CMakeLists.txt-Datei vornehmen, führt Visual Studio automatisch den CMake-Konfigurationsschritt aus. Sie können den Konfigurationsschritt manuell aufrufen: Wählen Sie Projekt > Cache konfigurieren aus der Symbolleiste aus. Sie können Ihre Konfigurationseinstellungen unter Tools>Optionen>CMake>Allgemein ändern.

Screenshot der CMake-Konfigurationsoptionen im Visual Studio-Einstellungsfenster.

Die CMake-Konfigurationseinstellungen werden angezeigt. „CMake-Cachebenachrichtigungen anzeigen“ ist ausgewählt. Unter „Wenn der Cache nicht mehr aktuell ist:“, wird die Option „Konfigurationsschritt nie automatisch ausführen“ ausgewählt.

Wenn der Konfigurationsschritt ohne Fehler abgeschlossen wird, werden die verfügbaren Informationen für IntelliSense für C++ und Sprachdienste verwendet. Er wird auch in Erstellungs- und Debugvorgängen verwendet.

Sie können auch einen vorhandenen CMake-Cache in Visual Studio öffnen. Weitere Informationen finden Sie unter Öffnen eines vorhandenen Caches.

Anpassen von Konfigurationsfeedback und -benachrichtigungen

Die meisten Konfigurationsmeldungen werden standardmäßig unterdrückt, es sei denn, es ist ein Fehler aufgetreten. Um alle Nachrichten anzuzeigen, wählen Sie Tools>Optionen>CMake>Ausführliche CMake-Diagnoseausgabe aktivieren aus.

Sie können auch alle CMake-Cachebenachrichtigungen (goldene Leisten) deaktivieren, indem Sie die Auswahl von Show CMake cache notification (CMake-Cachebenachrichtigungen anzeigen) aufheben.

Behandlung von CMake-Cachefehlern

Wenn Sie weitere Informationen zum Status des CMake-Caches benötigen, um ein Problem zu diagnostizieren, öffnen Sie das Hauptmenü Projekt oder das Kontextmenü von CMakeLists.txt im Projektmappen-Explorer, um einen der folgenden Befehle auszuführen:

  • CMakeCache.txt anzeigen öffnet die CMakeCache.txt-Datei aus dem Buildverzeichnis im Editor. Alle Änderungen, die Sie hier an CMakeCache.txt vornehmen, werden gelöscht, wenn Sie den Cache bereinigen. Informationen zum Vornehmen von Änderungen, die nach dem Bereinigen des Caches beibehalten werden, finden Sie unter Anpassen von CMake-Einstellungen oder Konfigurieren und Kompilieren mit CMake-Voreinstellungen.

  • Cache löschen und neu konfigurieren konfiguriert das Buildverzeichnis und konfiguriert aus einem bereinigten Cache neu.

  • Cache konfigurieren erzwingt das Ausführen des Schritts „Generieren“, auch wenn Visual Studio die Umgebung für aktuell hält.

Erstellen von CMake-Projekten

Der CMake-Buildschritt erstellt eine bereits generierte Projektbinärstruktur. Dies entspricht dem Aufrufen von cmake --build über die Befehlszeile. Weitere Informationen zum CMake-Buildschritt finden Sie in der CMake-Dokumentation.

Folgende Optionen stehen Ihnen zum Erstellen eines CMake-Projekts zur Verfügung:

  1. Suchen Sie in der Symbolleiste nach der Dropdownliste Startelement. Wählen Sie das bevorzugte Ziel aus, und drücken Sie F5, oder wählen Sie die Schaltfläche Ausführen auf der Symbolleiste aus. Das Projekt wird genau wie eine Visual Studio-Projektmappe zunächst erstellt.

  2. Klicken Sie im Projektmappen-Explorer mit aktivierter CMake-Zielansicht mit der rechten Maustaste auf das CMake-Ziel, und wählen Sie im Kontextmenü Erstellen aus.

  3. Wählen Sie im Hauptmenü Erstellen >> Alle erstellen aus. Stellen Sie sicher, dass ein CMake-Ziel bereits in der Dropdownliste Startelement auf der Symbolleiste ausgewählt ist.

Erwartungsgemäß werden die Buildergebnisse im Ausgabefenster und in der Fehlerliste angezeigt.

Screenshot des Fensters „Visual Studio-Fehlerliste“. CMake-Buildwarnungen zu Konvertierungen, die zu Datenverlusten führen können, z. B. das Konvertieren von einem Float in eine ganze Zahl, sind sichtbar. :::image-end:::

Bearbeiten von Buildeinstellungen

Visual Studio verwendet eine CMake-Konfigurationsdatei um CMake-Builds zu steuern. CMake-Konfigurationsdateien kapseln Buildoptionen wie native Buildtoolsoptionen und Umgebungsvariablen. Wenn CMakePresets.json Ihre aktive Konfigurationsdatei ist, finden Sie weitere Informationen unter Konfigurieren und Kompilieren mit CMake-Voreinstellungen. Wenn CMakeSettings.json Ihre aktive Konfigurationsdatei ist, finden Sie weitere Informationen unter Anpassen von CMake-Buildeinstellungen. CMakePresets.json ist in Visual Studio 2019, Version 16.10 oder höher verfügbar und ist die empfohlene CMake-Konfigurationsdatei.

Debuggen von CMake-Projekten

Alle ausführbaren CMake-Ziele werden in der Dropdownliste Startelement in der Symbolleiste angezeigt. Wählen Sie zum Starten des Debuggens eine Option aus, und wählen Sie auf der Symbolleiste die Schaltfläche Debuggen > Debuggen starten aus. In einem CMake-Projekt ist die Option „Aktuelles Dokument“ nur für .cpp-Dateien gültig.

Screenshot der Visual Studio-Debugdropdownliste.

Die Dropdownliste hat diese Optionen: Debugziele anzeigen/ausblenden, aktuelles Dokument, Beispiele (hervorgehoben), box2d_tests und Beispiele-noGUI.

Die Befehle Debuggen oder F5 kompilieren das Projekt erst, wenn seit dem vorherigen Build Änderungen vorgenommen wurden. Änderungen an der CMake-Konfigurationsdatei (CMakePresets.json oder CMakeSettings.json) oder eine CMakeLists.txt sorgen dafür, dass der CMake-Cache neu generiert wird.

Sie können eine CMake-Debugsitzung durch Festlegen von Eigenschaften in der Datei launch.vs.json anpassen. Um die Debugeinstellungen für ein bestimmtes Ziel anzupassen, wählen Sie das Ziel in der Dropdownliste Startelement aus, und wählen Sie Debuggen > Debug- und Starteinstellungen für <aktives Ziel> aus. Weitere Informationen zu CMake-Debugsitzungen finden Sie unter Konfigurieren von CMake-Debugsitzungen.

„Nur eigenen Code“ für CMake-Projekte

Wenn Sie für Windows mit dem MSVC-Compiler erstellen, unterstützen CMake-Projekte das „Nur eigenen Code“-Debuggen. Navigieren Sie zu Extras>Optionen>Debuggen>Allgemein, um die „Nur eigenen Code“-Einstellung zu ändern. Weitere Informationen zum Debuggen von „Nur eigenen Code“ finden Sie unter Debuggen von Benutzercode mit nur eigenem Code.

„Bearbeiten und Fortfahren“ für CMake-Projekte

Wenn Sie mit dem MSVC-Compiler für Windows kompilieren, unterstützen CMake-Projekte „Bearbeiten und Fortfahren“. Fügen Sie der CMakeLists.txt-Datei den folgenden Code hinzu, um „Bearbeiten und Fortfahren“ zu aktivieren. Weitere Informationen zu „Bearbeiten“ und „Fortfahren“ finden Sie unter Konfigurieren von „Bearbeiten“ und „Fortfahren“ (C#, VB, C++).

if(MSVC)
  target_compile_options(<target> PUBLIC "/ZI")
  target_link_options(<target> PUBLIC "/INCREMENTAL")
endif()

Anfügen eines CMake-Projekts unter Linux

In Visual Studio können Sie einen Prozess debuggen, der auf einem Linux-Remotesystem oder WSL ausgeführt wird, und ihn mit dem GDB-Debugger debuggen. Wählen Sie zum Einstieg Debuggen>An den Prozess anhängen... aus, legen Sie den Verbindungstyp auf SSH fest, und wählen Sie Ihr Verbindungsziel aus der Liste der Verbindungen im Verbindungs-Manager aus. Wählen Sie einen Prozess aus der Liste der verfügbaren Prozesse aus, und klicken Sie auf Anfügen. GDB muss auf Ihrem Linux-Computer installiert sein. Weitere Informationen zu SSH-Verbindungen finden Sie im Verbindungs-Manager.

Screenshot des Menüs „An Prozess anhängen“ in Visual Studio.

Die folgenden Optionen sind im Dialogfeld verfügbar: der Verbindungstyp (auf SSH festgelegt), das Verbindungsziel (auf demo@ 172.20.60.6 festgelegt) und eine Liste der verfügbaren Prozesse, an die Sie anfügen können.

Partielle CMake-Aktivierung

In Visual Studio 2022, Version 17.1 und höher, wird die CMake-Funktionalität nicht automatisch aktiviert, wenn Ihr Stammordner keine CMakeLists.txt-Datei enthält. Stattdessen werden Sie in einem Dialogfeld gefragt, ob Sie die CMake-Funktionalität für Ihr Projekt aktivieren möchten. Wenn Sie ablehnen, wird die CMake-Cachegenerierung nicht gestartet, und CMake-Konfigurationen (von CMakeSettings.json oder CMakePresets.json) werden nicht in der Konfigurationsdropdownliste angezeigt. Wenn Sie akzeptieren, werden Sie zu einer Konfigurationsdatei auf Arbeitsbereichsebene, CMakeWorkspaceSettings.json (gespeichert im Verzeichnis .vs), weitergeleitet, um die Ordner anzugeben, für die Sie CMake aktivieren möchten. (Diese Ordner enthalten Ihre CMakeLists.txt-Stammdateien).

Die akzeptierten Eigenschaften sind:

Eigenschaft Beschreibung
enableCMake Aktivieren Sie die Integration von Visual Studio für diesen Arbeitsbereich.
sourceDirectory Eine Zeichenfolge oder ein Array von Zeichenfolgen, die das Verzeichnis oder die Verzeichnisse mit CMakeLists.txt festlegen. Makros (z. B. ${workspaceRoot}) sind zulässig. Relative Pfade basieren auf dem Arbeitsbereichsstammverzeichnis. Verzeichnisse außerhalb des aktuellen Arbeitsbereichs werden ignoriert.

Sie können CMakeWorkspaceSettings.json jederzeit über den Menübefehl Projekt>CMake-Arbeitsbereichseinstellungen aufrufen, auch wenn die CMake-Funktionalität deaktiviert ist.

Öffnen eines vorhandenen Caches

Wenn Sie eine vorhandene CMake-Cachedatei (CMakeCache.txt) öffnen, versucht Visual Studio nicht, Ihren Cache und die Buildstruktur für Sie zu verwalten. Ihre benutzerdefinierten oder bevorzugten Tools haben die umfassende Kontrolle darüber, wie CMake das Projekt konfiguriert.

Sie können einem geöffneten Projekt einen vorhandenen CMake-Cache hinzufügen. Dies erfolgt auf die gleiche Weise wie das Hinzufügen einer neuen Konfiguration. Weitere Informationen finden Sie in unserem Blogbeitrag zum Öffnen eines vorhandenen Caches in Visual Studio.

Hinweis

Das vorhandene Standardcaching basiert auf cmake-server. Dieses Feature wurde in Version 3.20 aus CMake entfernt. Ergreifen Sie eine der folgenden Maßnahmen, um die Cachingfunktionalität in Visual Studio 2019 16.10 und höher weiterhin zu verwenden:

  • Installieren Sie CMake 3.19 oder niedriger manuell. Legen Sie dann die Eigenschaft cmakeExecutable in Ihrer vorhandenen Cachekonfiguration auf diese Version von CMake fest.
  • Legen Sie in Ihrer vorhandenen Cachekonfiguration die Eigenschaft cacheGenerationCommand fest, damit Visual Studio die erforderlichen dateibasierten API-Dateien für CMake anfordern kann. Weitere Informationen zu dieser Eigenschaft finden Sie in der Referenz zu „CMakeSettings.json“.
  • Verwenden Sie eine Abfragedatei, um die dateibasierten API-Dateien für CMake anzufordern, wenn Sie Ihren Cache generieren, bevor er in Visual Studio geöffnet wird. Anleitungen zu Abfragedateien finden Sie im nächsten Abschnitt, Erweiterte Problembehandlung für den CMake-Cache.

Erweiterte Problembehandlung für den CMake-Cache

Visual Studio verwendet die dateibasierte API von CMake (in Version 3.14 und höher), um den Editor mit Informationen für die jeweilige Projektstruktur zu füllen. Weitere Informationen finden Sie im Blogbeitrag des C++-Teams zu Multi-Root-Arbeitsbereichen und der dateibasierten API.

Vor dem Generieren des CMake-Caches müssen Ihre benutzerdefinierten oder bevorzugten Tools möglicherweise eine Abfragedatei mit dem Namen .cmake/api/v1/query/client-MicrosoftVS/query.json im Buildausgabeordner erstellen (der Ordner, der CMakeCache.txt enthält). Die Abfragedatei sollte diesen Inhalt enthalten:

{"requests":[{"kind":"cache","version":2},{"kind":"cmakeFiles","version":1},{"kind":"codemodel","version":2}]}

Wenn Ihre benutzerdefinierten oder bevorzugten Tools den Cache generieren, speichert CMake Dateien unter .cmake/api/v1/response. Diese werden von Visual Studio verwendet, um den Editor mit Informationen für die jeweilige Projektstruktur zu füllen.

Bearbeiten von CMakeLists.txt-Dateien

Wenn Sie eine CMakeLists.txt-Datei bearbeiten möchten, klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Datei, und klicken Sie auf Öffnen. Wenn Sie Änderungen an der Datei vornehmen, wird eine gelbe Statusleiste angezeigt, die Sie darüber informiert, dass IntelliSense ein Update durchführen möchte. Sie haben die Möglichkeit, den Updatevorgang abzubrechen. Weitere Informationen zu CMakeLists.txt finden Sie in der CMake-Dokumentation.

Screenshot einer CMake Lists .txt Datei, die in Visual Studio bearbeitet wird.

Es enthält die Zeilen project (hello-cmake), add_subdirectory (tests), add_executable (hello hello.cpp), und install (TARGETS hello DESTINATION hello/bin). Eine Meldung am oberen Rand des Fensters besagt, dass C++ IntelliSense-Informationen aktualisiert werden, nachdem CMake die Erstellung des Caches abgeschlossen hat.

Sobald Sie die Datei speichern, wird der Konfigurationsschritt automatisch erneut ausgeführt. Dieser zeigt Informationen im Ausgabefenster an. Fehler und Warnungen werden in der Fehlerliste oder im Ausgabefenster angezeigt. Doppelklicken Sie auf einen Fehler in der Fehlerliste, um zur problematischen Zeile in CMakeLists.txt zu navigieren.

Screenshot eines CMake-Fehlers in der Visual Studio Fehlerliste.

Eine CMake-Fehlermeldung in Zeile 3 der Datei CMakeLists.txt ist hervorgehoben. Das Problem besteht darin, dass CMake eine von sqlite3 bereitgestellte Paketkonfigurationsdatei nicht finden konnte. CMake hat unter CMAKE_MODULE_PATH danach gesucht, konnte es aber nicht finden. Der Vorschlag ist, das Installationspräfix „sqlite3“ zu CMAKE_PREFIX_PATH hinzuzufügen oder sqlite3_DIR auf ein Verzeichnis festzulegen, das sqlite3Config.cmake und/oder sqlitet3-config.cmake enthält.

Sprachdienste für CMake

Sprachdienste für CMake sind ab Visual Studio 2019, Version 16.5 verfügbar. Es unterstützt Codenavigationsfeatures wie „Gehe zu Definition“, „Peek-Definition“ und „Alle Verweise suchen“ für CMake-Variablen, -Funktionen und -Ziele in CMake-Skriptdateien. Weitere Informationen finden Sie unter Codenavigation für CMake-Skripts.

Screenshot des Fensters „Alle Verweise suchen“ in Visual Studio.

Es wird angezeigt, wo SUPERTUX_SOURCES_CXX gefunden wird. Zum Beispiel in list(SORT SSUPERTUX_SOURCES_CXX), file(GLOB SUPERTUX_SOURCES_CXX) und so weiter.

CMake-Projektbearbeitung

Die CMake-Projektbearbeitung ist ab Visual Studio 2019, Version 16.5 verfügbar. Mit der Projektbearbeitung können Sie Quelldateien und Ziele in Ihrem CMake-Projekt hinzufügen, entfernen und umbenennen, ohne Ihre CMake-Skripts manuell bearbeiten zu müssen. Beim Hinzufügen oder Entfernen von Dateien aus dem Projektmappen-Explorer wird Ihr CMake-Projekt automatisch von Visual Studio bearbeitet. Es könnte mehr als eine Stelle geben, an der es sinnvoll ist, einen Verweis auf ein CMake-Skript hinzuzufügen oder zu entfernen. Wenn dies der Fall ist, fragt Visual Studio Sie, wo Sie die Änderung vornehmen möchten, und zeigt eine Vorschau der vorgeschlagenen Änderungen an. Eine Schritt-für-Schritt-Anleitung finden Sie unter Hinzufügen, Entfernen und Umbenennen von Dateien und Zielen in CMake-Projekten.

Screenshot des Dialogfelds „Vorschau der Änderungen in Visual Studio“.

Eine Strukturansicht zeigt CMakeLists.txt an, unter der sich zwei Einträge befinden: „add_executable“ und „set“. „Set“ ist aktiviert. Im Vorschaufenster wird angezeigt, wo Änderungen vorgenommen werden. In der Zeile set (PROJECT_SRC "CmakeProject4.cpp" "CMakeProject4.h" ist "Demo.cpp" vor der schließenden Klammer hervorgehoben. Mit der Schaltfläche „Übernehmen“ akzeptieren Sie die Änderung. Sie können auch „Abbrechen“ auswählen.

IntelliSense für CMake-Projekte

Standardmäßig verwendet Visual Studio den IntelliSense-Modus, der der Compiler- und Zielarchitektur entspricht, die von der aktiven CMake-Konfiguration angegeben wird.

Wenn CMakePresets.json Ihre aktive CMake-Konfigurationsdatei ist, können Sie IntelliSense-Optionen mit intelliSenseMode und intelliSenseOptions in der Anbieterzuordnung in den Visual Studio-Einstellungen angeben. Weitere Informationen finden Sie unter Referenz zu den Anbieterzuordnungen in den Visual Studio-Einstellungen.

Wenn CMakeSettings.json Ihre aktive CMake-Konfigurationsdatei ist, können Sie IntelliSense-Optionen mit intelliSenseMode in CMakeSettings.json angeben. Weitere Informationen finden Sie in der Referenz zu CMakeSettings.json.

Konfigurieren von IntelliSense mit CMake-Toolkettendateien

In Visual Studio 2019 Version 16.9 und später konfiguriert Visual Studio IntelliSense automatisch in CMake-Projekten basierend auf CMake-Variablen, wenn Sie die CMake-Toolkettendatei verwenden. Weitere Informationen finden Sie unter Konfigurieren von IntelliSense mit CMake-Toolkettendateien.

Vcpkg-Integration

CMake-Projekte, die in Visual Studio geöffnet sind, können mit vcpkg integriert sein, einem plattformübergreifenden C/C++-Abhängigkeits-Manager. Bevor Sie vcpkg mit Visual Studio verwenden, müssen Sie vcpkg integrate install ausführen. Anweisungen und weitere Informationen zu vcpkg finden Sie unter:

Wenn CMakeSettings.json Ihre aktive Konfigurationsdatei ist, übergibt Visual Studio die vcpkg-Toolkettendatei (vcpkg.cmake) automatisch an CMake. Dieses Verhalten wird automatisch deaktiviert, wenn Sie eine andere Toolkette in der Konfiguration der CMake-Einstellungen angeben.

Wenn CMakePresets.json Ihre aktive Konfigurationsdatei ist, müssen Sie den Pfad auf vcpkg.cmake in CMakePresets.json festlegen. Es wird empfohlen, die VCPKG_ROOT-Umgebungsvariable anstelle eines absoluten Pfads zu verwenden, damit die Datei gemeinsam verwendet werden kann. Weitere Informationen finden Sie unter Aktivieren der vcpkg-Integration mit CMake-Voreinstellungen. CMakePresets.json ist in Visual Studio 2019, Version 16.10 oder höher verfügbar und ist die empfohlene CMake-Konfigurationsdatei.

Ausführen von CMake über die Befehlszeile

Wenn CMakePresets.json Ihre aktive CMake-Konfigurationsdatei ist, können Sie Ihre lokalen Builds problemlos außerhalb von Visual Studio reproduzieren. Weitere Informationen finden Sie unter Ausführen von CMake über die Befehlszeile oder eine CI-Pipeline. CMakePresets.json wird in Visual Studio 2019, Version 16.10 oder höher unterstützt und ist die empfohlene CMake-Konfigurationsdatei.

Wenn CMakeSettings.json Ihre aktive CMake-Konfigurationsdatei ist, müssen Sie die Argumente, die in Ihrer CMakeSettings.json-Datei codiert sind, manuell an CMake übergeben. Wenn Sie CMake über den Visual Studio-Installer installiert haben, können Sie CMake über die Befehlszeile ausführen, indem Sie die folgenden Schritte ausführen:

  1. Führen Sie die entsprechende Datei vsdevcmd.bat (x86/x64) aus. Weitere Informationen finden Sie unter Erstellen über die Befehlszeile.

  2. Wechseln Sie zu Ihrem Ausgabeordner.

  3. Führen Sie CMake zum Erstellen oder Konfigurieren Ihrer App aus.

Visual Studio 2017 bietet umfangreiche Unterstützung für CMake einschließlich plattformübergreifender CMake-Projekte. Die Komponente Visual C++-Tools für CMake verwendet die Funktion Ordner öffnen, um der IDE die Verwendung von CMake-Projektdateien (z. B. CMakeLists.txt) direkt für IntelliSense und das Durchsuchen zu ermöglichen. Es werden sowohl Ninja- als auch Visual Studio-Generatoren unterstützt. Wenn Sie einen Visual Studio-Generator verwenden, generiert dieser eine temporäre Projektdatei und übergibt sie an MSBuild. Das Projekt wird jedoch nie für IntelliSense oder zum Durchsuchen geladen. Sie können auch einen vorhandenen CMake-Cache verwenden.

Installation

Die Komponente Visual C++-Tools für CMake wird standardmäßig als Teil der Workloads Desktopentwicklung mit C++ und Linux Entwicklung mit C++ installiert.

Screenshot des Visual Studio-Installers Die Registerkarte „Einzelne Komponenten“ ist ausgewählt. Darauf sind die Visual C++-Tools für CMake ausgewählt.

Weitere Informationen finden Sie unter Install the C++ Linux workload in Visual Studio (Installieren der C++-Workload unter Linux in Visual Studio).

IDE-Integration

Wenn Sie Datei > Öffnen > Ordner auswählen, um einen Ordner zu öffnen, der die Datei CMakeLists.txt enthält, geschieht Folgendes:

  • Visual Studio fügt ein CMake-Menüelement zum Hauptmenü hinzu, das Befehle für das Anzeigen und Bearbeiten von CMake-Skripts enthält.

  • Der Projektmappen-Explorer zeigt die Ordnerstruktur und die Dateien an.

  • Visual Studio führt CMake aus und generiert optional den CMake-Cache für die Standardkonfiguration (x86 Debug). Die CMake-Befehlszeile wird im Ausgabefenster zusammen mit weiteren Ausgaben von CMake angezeigt.

  • Im Hintergrund beginnt Visual Studio damit, die Quelldateien zu indizieren, um IntelliSense, das Durchsuchen von Informationen, das Refactoring und vieles mehr zu ermöglichen. Während Sie arbeiten, überwacht Visual Studio die Änderungen im Editor und auf dem Datenträger, damit der Index mit den Quellen synchron ist.

Sie können Ordner öffnen, die eine beliebige Anzahl von CMake-Projekten enthalten. Visual Studio erkennt und konfiguriert alle CMakeLists.txt-Stammdateien in Ihrem Arbeitsbereich. CMake-Vorgänge (Konfigurieren, Erstellen, Debuggen), IntelliSense für C++ und das Durchsuchen sind für alle CMake-Projekte in Ihrem Arbeitsbereich verfügbar.

Screenshot des Visual Studio-Projektmappen-Explorers

Die Dateien und Ordner eines CMake-Projekts sind sichtbar. Es gibt ein Unterverzeichnis für Tests sowie die Dateien CMakeLists.txt und hello.cpp. Es gibt einen Ordner hello-cmake-vcpkg, der die Dateien CMakeLists.txt, CMakeSettings.json und hello.cpp enthält.

Sie können die Projekte auch logisch strukturiert nach Zielen anzeigen. Wählen Sie in der Dropdownliste der Symbolleiste des Projektmappen-Explorers die Option Zielansicht aus:

Screenshot der Dropdownschaltfläche im Visual Studio-Projektmappen-Explorer mit der Option „CMake-Zielansicht“ Diese Option ist ausgewählt.

Visual Studio verwendet die Datei CMakeSettings.json zum Speichern von Umgebungsvariablen oder Befehlszeilenoptionen für CMake. CMakeSettings.json ermöglicht außerdem das Definieren und Speichern mehrerer CMake-Buildkonfigurationen. Sie können in der IDE bequem zwischen ihnen wechseln.

Verwenden Sie CMakeLists.txt andernfalls einfach wie in jedem anderen CMake-Projekt zum Angeben von Quelldateien, Suchen von Bibliotheken, Festlegen von Compiler- und Linkeroptionen sowie zum Angeben weiterer Informationen zum Buildsystem.

Wenn Sie beim Debuggen Argumente an eine ausführbare Datei übergeben müssen, können Sie eine andere Datei mit dem Namen launch.vs.json verwenden. In einigen Szenarios werden diese Dateien von Visual Studio automatisch generiert. Sie können sie manuell bearbeiten oder sogar die Datei selbst erstellen.

Hinweis

Für andere Arten von „Ordner öffnen“-Projekten werden zwei zusätzliche JSON-Dateien verwendet: CppProperties.json und tasks.vs.json. Diese sind für CMake-Projekte jedoch nicht relevant.

Importieren eines vorhandenen Caches

Wenn Sie eine vorhandene CMakeCache.txt-Datei importieren, extrahiert Visual Studio benutzerdefinierte Variablen automatisch und erstellt die vorab aufgefüllte Datei CMakeSettings.json, die auf diesen basiert. Der ursprüngliche Cache wird in keiner Weise geändert. Er kann weiterhin über die Befehlszeile oder mit einem beliebigen Tool oder der IDE verwendet werden, die zum Generieren verwendet werden. Die neue Datei CMakeSettings.json wird bei der CMakeLists.txt-Stammdatei des Projekts platziert. Visual Studio generiert einen neuen Cache, der auf der Einstellungsdatei basiert. Sie können die automatische Cachegenerierung im Dialogfeld Extras > Optionen > CMake > Allgemein außer Kraft setzen.

Nicht der gesamte Inhalt des Caches wird importiert. Eigenschaften wie der Generator und der Speicherort des Compilers werden durch die Standardwerte ersetzt, die in der IDE bekanntermaßen funktionieren.

Importieren eines vorhandenen Caches

  1. Wählen Sie im Hauptmenü Datei > Öffnen > CMake aus:

    Screenshot des Visual Studio-Hauptmenüs „Datei > Öffnen > CMake“ ist ausgewählt.

    Mit diesem Befehl wird der Assistent CMake-Projekt aus Cache importieren gestartet.

  2. Navigieren Sie zur Datei CMakeCache.txt, die Sie importieren möchten, und klicken Sie dann auf OK. Der Assistent CMake-Projekt aus Cache importieren wird angezeigt:

    Screenshot des Assistenten zum Importieren eines CMake-Projekt aus dem Cache Der Verzeichnispfad des zu importierenden CMake-Projekts wird in das Textfeld „Ordner“ verschoben.

    Wenn der Assistent abgeschlossen ist, wird die neue Datei CMakeCache.txt im Projektmappen-Explorer neben der CMakeLists.txt-Stammdatei in Ihrem Projekt geöffnet.

Erstellen von CMake-Projekten

Folgende Optionen stehen Ihnen zum Erstellen eines CMake-Projekts zur Verfügung:

  1. Suchen Sie auf der Symbolleiste „Allgemein“ nach dem Dropdownmenü Konfigurationen. Es wird wahrscheinlich standardmäßig „Linux-Debug“ oder „x64-Debug“ angezeigt. Klicken Sie auf die bevorzugte Konfiguration, und drücken Sie F5 oder klicken Sie auf der Symbolleiste auf die Schaltfläche Ausführen (grünes Dreieck). Das Projekt wird genau wie eine Visual Studio-Projektmappe zunächst erstellt.

  2. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf CMakeLists.txt, und klicken Sie dann im Kontextmenü auf Erstellen. Wenn mehrere Ziele in Ihrer Ordnerstruktur vorhanden sind, können Sie auswählen, den Build für alle oder nur für ein bestimmtes Ziel durchzuführen.

  3. Alternativ können Sie im Hauptmenü Erstellen > Projektmappe erstellen auswählen (F7 oder STRG+UMSCHALT+B). Stellen Sie sicher, dass ein CMake-Ziel bereits in der Dropdownliste Startelement auf der Symbolleiste Allgemein ausgewählt ist.

Screenshot des Visual Studio-Projektmappen-Explorers, nachdem Sie mit der rechten Maustaste auf CMakeLists.txt geklickt haben

Das Menü enthält Optionen wie „Hinzufügen“, „Öffnen“, „Aufgaben konfigurieren“, „Erstellen“, „Alle bereinigen“ usw.

Sie können Buildkonfigurationen, Umgebungsvariablen, Befehlszeilenargumente und andere Einstellungen in der Datei CMakeSettings.json anpassen. Sie können Änderungen vornehmen, ohne die Datei CMakeLists.txt zu ändern. Weitere Informationen finden Sie unter Customize CMake settings (Anpassen von CMake-Einstellungen).

Erwartungsgemäß werden die Buildergebnisse im Ausgabefenster und in der Fehlerliste angezeigt.

Screenshot des Fensters „Visual Studio-Fehlerliste“

CMake-Buildwarnungen zu Konvertierungen, die zu Datenverlusten führen können, z. B. das Konvertieren von einem Float in eine ganze Zahl, sind sichtbar.

In einem Ordner mit mehreren Buildzielen können Sie angeben, welches CMake-Ziel erstellt werden soll: Wählen Sie das Element Erstellen im Menü CMake oder das Kontextmenü von CMakeLists.txt aus, um das Ziel anzugeben. Wenn Sie in einem CMake-Projekt STRG+UMSCHALT+B drücken, wird das derzeit aktive Dokument erstellt.

Debuggen von CMake-Projekten

Wenn Sie ein CMake-Projekt debuggen möchten, wählen Sie die gewünschte Konfiguration aus, und drücken Sie F5. Alternativ können Sie auf die Schaltfläche Ausführen auf der Symbolleiste klicken. Wenn die Schaltfläche Ausführen „Startelement auswählen“ anzeigt, klicken Sie auf den Dropdownpfeil, und wählen Sie das Ziel aus, das ausgeführt werden soll. (In einem CMake-Projekt ist die Option „Aktuelles Dokument“ nur für CPP-Dateien gültig.)

Screenshot der Dropdownliste „Startelement auswählen“ für ein CMake-Projekt Sie können das aktuelle Dokument oder hello-cmake.exe auswählen.

Durch Ausführen oder F5 wird das Projekt zunächst erstellt, wenn seit dem vorherigen Build Änderungen vorgenommen wurden.

Sie können eine CMake-Debugsitzung durch Festlegen von Eigenschaften in der Datei launch.vs.json anpassen. Weitere Informationen finden Sie unter Configure CMake debugging sessions (Konfigurieren von CMake-Debugsitzungen).

Bearbeiten von CMakeLists.txt-Dateien

Wenn Sie eine CMakeLists.txt-Datei bearbeiten möchten, klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Datei, und klicken Sie auf Öffnen. Wenn Sie Änderungen an der Datei vornehmen, wird eine gelbe Statusleiste angezeigt, die Sie darüber informiert, dass IntelliSense ein Update durchführen möchte. Sie haben die Möglichkeit, den Updatevorgang abzubrechen. Weitere Informationen zu CMakeLists.txt finden Sie in der CMake-Dokumentation.

Screenshot einer CMake Lists .txt Datei, die in Visual Studio bearbeitet wird.

Die Datei enthält: project (hello-cmake), add_subdirectory (tests), add_executable (hello hello.cpp), und install (TARGETS hello DESTINATION hello/bin). Eine Meldung am oberen Rand des Fensters besagt, dass C++ IntelliSense-Informationen aktualisiert werden, nachdem CMake die Erstellung des Caches abgeschlossen hat.

Sobald Sie die Datei speichern, wird der Konfigurationsschritt automatisch erneut ausgeführt. Dieser zeigt Informationen im Ausgabefenster an. Fehler und Warnungen werden in der Fehlerliste oder im Ausgabefenster angezeigt. Doppelklicken Sie auf einen Fehler in der Fehlerliste, um zur problematischen Zeile in CMakeLists.txt zu navigieren.

Screenshot eines CMake-Fehlers in der Visual Studio Fehlerliste.

Eine CMake-Fehlermeldung in Zeile 3 der Datei CMakeLists.txt ist hervorgehoben. Das Problem besteht darin, dass CMake eine von sqlite3 bereitgestellte Paketkonfigurationsdatei nicht finden konnte. CMake hat unter CMAKE_MODULE_PATH danach gesucht, konnte es aber nicht finden. Der Vorschlag ist, das Installationspräfix „sqlite3“ zu CMAKE_PREFIX_PATH hinzuzufügen oder sqlite3_DIR auf ein Verzeichnis festzulegen, das sqlite3Config.cmake und/oder sqlitet3-config.cmake enthält.

CMake-Konfigurationsschritt

Wenn wichtige Änderungen an der Datei CMakeSettings.json oder CMakeLists.txt vorgenommen werden, führt Visual Studio den CMake-Konfigurationsschritt automatisch erneut aus. Wenn der Konfigurationsschritt ohne Fehler abgeschlossen wird, sind die gesammelten Informationen in IntelliSense für C++ und den Sprachdiensten verfügbar. Er wird auch in Erstellungs- und Debugvorgängen verwendet.

Mehrere CMake-Projekte verwenden möglicherweise denselben CMake-Konfigurationsnamen (z. B. „x86-Debug“). Wenn diese Konfiguration ausgewählt ist, werden diese (in ihrem eigenen Buildstammordner) konfiguriert und erstellt. Sie können die Ziele aller CMake-Projekte debuggen, die in dieser CMake-Konfiguration enthalten sind.

Screenshot des Hauptmenüs von Visual Studio, das nur für CMake > Build geöffnet ist

Das Kontextmenü zeigt an, was kompiliert werden kann – in diesem Fall hello-cmake-a \ hello-cmake.exe (Projekt hello-cmake) und hello-cmake-b\hello-cmake.exe (Projekt hello-cmake). Letzteres ist hervorgehoben.

Sie können Build- und Debugsitzungen auf eine Teilmenge der Projekte im Arbeitsbereich beschränken. Erstellen Sie in der Datei CMakeSettings.json eine neue Konfiguration mit einem eindeutigen Namen. Wenden Sie die Konfiguration dann nur auf diese Projekte an. Wenn diese Konfiguration ausgewählt ist, werden IntelliSense und die Build- und Debugbefehle nur für die angegebenen Projekte angewendet.

Behandlung von CMake-Cachefehlern

Wenn Sie weitere Informationen zum Status des CMake-Caches benötigen, um ein Problem zu diagnostizieren, öffnen Sie das Hauptmenü CMake oder das Kontextmenü von CMakeLists.txt im Projektmappen-Explorer, um einen der folgenden Befehle auszuführen:

  • Cache anzeigen öffnet die Datei CMakeCache.txt aus dem Stammordner des Builds im Editor. (Alle Änderungen, die Sie hier an CMakeCache.txt vornehmen, werden verworfen, wenn Sie den Cache bereinigen.) Informationen zum Vornehmen von Änderungen, die nach dem Bereinigen des Caches beibehalten werden, finden Sie unter Anpassen von CMake-Einstellungen.)

  • Cacheordner öffnen öffnet ein Explorer-Fenster zum Stammordner des Builds.

  • Cache bereinigen löscht den Stammordner des Builds, sodass der nächste CMake-Konfigurationsschritt mit einem leeren Cache beginnt.

  • Cache generieren erzwingt die Ausführung des Schritts „Generieren“, auch wenn Visual Studio die Umgebung für aktuell hält.

Die automatische Cachegenerierung kann im Dialogfeld Extras > Optionen > CMake > Allgemein deaktiviert werden.

Kompilierung einzelner Dateien

Klicken Sie zum Erstellen einer einzelnen Datei in einem CMake-Projekt im Projektmappen-Explorer mit der rechten Maustaste auf die Datei. Klicken Sie im Popupmenü auf Kompilieren. Sie können die derzeit im Editor geöffnete Datei auch über das CMake-Hauptmenü erstellen:

Screenshot des Kontextmenüs „CMake > Kompilieren“ Es enthält einen Eintrag: Bullet3Collision.

Ausführen von CMake über die Befehlszeile

Wenn Sie CMake über den Visual Studio-Installer installiert haben, können Sie CMake über die Befehlszeile ausführen, indem Sie die folgenden Schritte ausführen:

  1. Führen Sie die entsprechende Datei vsdevcmd.bat (x86/x64) aus. Weitere Informationen finden Sie unter Erstellen über die Befehlszeile.

  2. Wechseln Sie zu Ihrem Ausgabeordner.

  3. Führen Sie CMake zum Erstellen oder Konfigurieren Ihrer App aus.

In Visual Studio 2015 können Visual Studio-Benutzer einen CMake-Generator verwenden, um MSBuild-Projektdateien zu generieren, die anschließend von der IDE für IntelliSense sowie für das Durchsuchen und die Kompilierung verwendet werden.

Weitere Informationen

Tutorial: Erstellen plattformübergreifender C++-Projekte in Visual Studio
Konfigurieren eines Linux CMake-Projekts
Herstellen einer Verbindung mit Ihrem Linux-Remotecomputer
Anpassen von CMake-Buildeinstellungen
CMakeSettings.json-Schemareferenz
Konfigurieren von CMake-Debugsitzungen
Bereitstellen, Ausführen und Debuggen Ihres Linux-Projekts
CMake predefined configuration reference (Referenz für vordefinierte CMake-Konfigurationen)
vcpkg in CMake-Projekten
Installieren und Verwenden von Paketen mit CMake in Visual Studio