Tutorial: Erstellen plattformübergreifender C++-Projekte in Visual Studio

Artikel
10/18/2023

Die Entwicklung mit C und C++ in Visual Studio eignet sich nicht nur für Windows-Anwendungen. In diesem Tutorial erfahren Sie, wie Sie Visual Studio für plattformübergreifende C++-Entwicklung für Windows und Linux verwenden. Da CMake die Grundlage dieses Tutorials darstellt, müssen Sie keine Visual Studio-Projekte erstellen oder generieren. Wenn Sie einen Ordner öffnen, der die Datei „CMakeLists.txt“ enthält, konfiguriert Visual Studio automatisch die IntelliSense- und Buildeinstellungen. Sie können umgehend damit beginnen, Ihren Code lokal unter Windows zu bearbeiten, zu erstellen und zu debuggen. Anschließend ändern Sie Ihre Konfiguration, um dasselbe für Linux ausschließlich über Visual Studio durchzuführen.

In diesem Tutorial lernen Sie Folgendes:

Klonen eines Open Source-CMake-Projekts über GitHub
Öffnen des Projekts in Visual Studio
Erstellen und Debuggen eines ausführbaren Ziels unter Windows
Hinzufügen einer Verbindung zu einem Linux-Computer
Erstellen und Debuggen des gleichen Ziels unter Linux

Voraussetzungen

Einrichten von Visual Studio für die plattformübergreifende C++-Entwicklung
- Zunächst installieren Sie Visual Studio und wählen dabei die Workloads Desktopentwicklung mit C++ und Linux-Entwicklung mit C++ aus. Diese Installation mit den mindestens erforderlichen Komponenten ist nur 3 GB groß. Je nach Downloadgeschwindigkeit sollte die Installation also nicht länger als 10 Minuten dauern.
Einrichten eines Linux-Computers für die plattformübergreifende C++-Entwicklung
- Visual Studio erfordert keine bestimmte Linux-Distribution. Das Betriebssystem kann auf einem physischen Computer, einer VM (virtueller Computer) oder in der Cloud ausgeführt werden. Sie können auch das Windows-Subsystem für Linux verwenden. Für dieses Lernprogramm ist jedoch eine grafische Umgebung erforderlich. Das Windows-Subsystem für Linux wird hier nicht empfohlen, weil es hauptsächlich für Befehlszeilenvorgänge vorgesehen ist.
- Visual Studio erfordert diese Tools auf dem Linux-Computer: C++-Compiler, gdb, , ssh, rsync, makeund zip. Aus Systemen, die auf Debian basieren, können Sie den folgenden Befehl verwenden, um diese Abhängigkeiten zu installieren:
```
sudo apt install -y openssh-server build-essential gdb rsync make zip
```
- Visual Studio erfordert eine aktuelle Version von CMake auf dem Linux-Computer, in der der Servermodus aktiviert ist (mindestens 3.8). Microsoft gibt einen universellen CMake-Build heraus, den Sie auf allen Linux-Distributionen veröffentlichen können. Es wird empfohlen, dass Sie diesen Build verwenden, damit Sie über die neuesten Features verfügen. Sie können die CMake-Binärdateien aus dem Microsoft-Fork des CMake-Repositorys auf GitHub herunterladen. Rufen Sie diese Seite auf, laden Sie die Version herunter, die mit der Systemarchitektur auf Ihrem Linux-Computer übereinstimmt, und markieren Sie diese als ausführbare Datei:
```
wget <path to binary>
chmod +x cmake-3.11.18033000-MSVC_2-Linux-x86_64.sh
```
- Sie sehen die Optionen zum Ausführen des Skripts mit --help. Es wird empfohlen, dass Sie die Option -prefix verwenden, um die Installation im Pfad /usr durchzuführen, da /usr/bin der Standardspeicherort ist, an dem Visual Studio nach CMake sucht. Im folgenden Beispiel sehen Sie das Linux-x86_64-Skript. Passen Sie dieses nach Bedarf an, wenn Sie eine andere Zielplattform verwenden.
```
sudo ./cmake-3.11.18033000-MSVC_2-Linux-x86_64.sh --skip-license --prefix=/usr
```
Auf Ihrem Windows-Computer muss Git für Windows installiert sein.
Ein GitHub-Konto.

Klonen eines Open Source-CMake-Projekts über GitHub

In diesem Tutorial wird das Bullet Physics SDK auf GitHub verwendet. Dieses bietet Kollisionserkennung und Physiksimulationen für viele Anwendungszwecke. Das SDK enthält Beispiel-ausführbare Programme, die kompiliert und ausgeführt werden, ohne anderen Code schreiben zu müssen. In diesem Tutorial wird der Quellcode nicht angepasst und es werden keine Skripts erstellt. Klonen Sie zunächst das Repository bullet3 von GitHub auf den Computer, auf dem Visual Studio installiert ist.

git clone https://github.com/bulletphysics/bullet3.git

Wählen Sie im Menü "Visual Studio Standard" die Option "Datei > öffnen > CMake" aus. Navigieren Sie im Stammverzeichnis des heruntergeladenen Aufzählungszeichens3 zu der CMakeLists.txt Datei.

Wenn Sie den Ordner öffnen, wird Ihre Ordnerstruktur im Projektmappen-Explorer angezeigt.

In dieser Ansicht sehen Sie genau, was sich auf dem Datenträger befindet. Die Ansicht ist nicht logisch oder gefiltert. Standardmäßig werden keine ausgeblendeten Dateien angezeigt.
Klicken Sie auf Alle Dateien anzeigen, um alle Dateien im Ordner anzuzeigen.

Wechseln zur Zielansicht

Wenn Sie einen Ordner öffnen, der CMake verwendet, generiert Visual Studio automatisch einen CMake-Cache. Je nach Größe des Projekts kann dieser Vorgang etwas Zeit in Anspruch nehmen.

Wählen Sie im AusgabefensterAusgabe anzeigen von: aus, und wählen Sie dann CMake, um den Status der Cacheerstellung zu überwachen. Wenn der Vorgang abgeschlossen ist, lautet die Meldung "Zielinformationenextraktion abgeschlossen".

Nach Abschluss dieses Vorgangs ist IntelliSense konfiguriert. Sie können das Projekt erstellen und die Anwendung debuggen. Visual Studio zeigt jetzt eine logische Ansicht der Projektmappe basierend auf den Zielen an, die in den CMakeLists-Dateien angegeben werden.
Über die Schaltfläche für Projektmappen und Ordner im Projektmappen-Explorer können Sie zur CMake-Zielansicht wechseln.

$Screenshot of the Solutions and Folders button in the Solution Explorer. It is selected, showing a dropdown with a choice for c:\projects\bullet3 and another choice for CMake Targets View, which is selected.$

So sieht diese Ansicht für das Bullet SDK aus:

Mit der Zielansicht erhalten Sie eine intuitivere Ansicht der Inhalte einer Quellbasis. Sie erkennen, dass einige Ziele Bibliotheken und andere ausführbare Dateien sind.
Erweitern Sie einen Knoten in der CMake-Zielansicht, um die Quellcodedateien anzuzeigen, egal wo sich diese auf dem Datenträger befinden.

Hinzufügen einer expliziten Windows x64-Debug-Konfiguration

Visual Studio erstellt eine x64-Debug-Standardkonfiguration für Windows. Durch Konfigurationen wird festgelegt, welche Plattformziele von Visual Studio für CMake verwendet werden sollen. Die Standardkonfiguration ist standardmäßig nicht auf dem Datenträger vorhanden. Wenn Sie eine Konfiguration explizit hinzufügen, erstellt Visual Studio eine Datei namens CMakeSettings.json. Diese wird mit den Einstellungen für alle Konfigurationen aufgefüllt, die Sie festlegen.

Fügen Sie eine neue Konfiguration hinzu. Öffnen Sie das Dropdownmenü Konfiguration in der Symbolleiste, und wählen Sie dann Konfigurationen verwalten aus.

Daraufhin wird der Editor für CMake-Einstellungen geöffnet. Klicken Sie auf das grüne Pluszeichen links neben dem Editor, um eine neue Konfiguration hinzuzufügen. Das Dialogfeld "Konfiguration zu CMake hinzufügen Einstellungen wird angezeigt:

In diesem Dialogfeld werden alle Konfigurationen angezeigt, die in Visual Studio enthalten sind, sowie alle benutzerdefinierten Konfigurationen, die Sie erstellt haben. Wenn Sie weiterhin eine x64-Debug-Konfiguration verwenden möchten, sollte dies der erste sein, den Sie hinzufügen. Wählen Sie x64-Debug aus, und klicken Sie dann auf Auswählen. Visual Studio erstellt die Datei „CMakeSettings.json“ mit einer Konfiguration für x64-Debug und speichert sie auf dem Datenträger. Sie können Ihre Konfigurationen beliebig benennen, indem Sie den Namensparameter direkt in „CMakeSettings.json“ ändern.

Festlegen eines Breakpoints, Erstellen und Ausführen unter Windows

In diesem Schritt debuggen wir ein Beispielprogramm, das die Aufzählungsphysik-Bibliothek veranschaulicht.

Wählen Sie „AppBasicExampleGui“ im Projektmappen-Explorer, und erweitern Sie es.
Öffnen Sie die Datei BasicExample.cpp.
Legen Sie einen Breakpoint fest, der erreicht werden soll, wenn Sie in der ausgeführten Anwendung klicken. Das Klickereignis wird in einer Methode in einer Hilfsklasse behandelt. Führen Sie folgende Schritte aus, um schnell dorthin zu gelangen:
1. Wählen Sie das CommonRigidBodyBase-Objekt, von dem die Struktur BasicExample abgeleitet wird. Dieses befindet sich etwa in Zeile 30.
2. Klicken Sie mit der rechten Maustaste, und wählen Sie Gehe zu Definition. Sie befinden sich nun im Header „CommonRigidBodyBase.h“.
3. In der Browseransicht über Ihrer Quelle sollten Sie sehen, dass Sie sich in CommonRigidBodyBase befinden. Rechts können Sie Member auswählen, die Sie sich genauer ansehen möchten. Öffnen Sie das Dropdownmenü, und wählen Sie mouseButtonCallback aus, um zur Definition dieser Funktion im Header zu wechseln.
Setzen Sie in der ersten Zeile dieser Funktion einen Breakpoint. Dieser wird erreicht, wenn Sie im Fenster der Anwendung einen Mausklick ausführen, wenn die Anwendung im Visual Studio-Debugger ausgeführt wird.
Klicken Sie auf das Startdropdownmenü in der Symbolleiste, um die Anwendung zu starten. Es ist das Symbol mit dem grünen Wiedergabesymbol, das "Startelement auswählen" besagt. Wählen Sie in der Dropdownliste "AppBasicExampleGui.exe" aus. Der Name der ausführbaren Datei wird jetzt auf der Startschaltfläche angezeigt:
Klicken Sie auf „Starten“, um die Anwendung und die erforderlichen Abhängigkeiten zu erstellen, und starten Sie sie dann mit angefügtem Visual Studio-Debugger. Nach kurzer Zeit wird die ausgeführte Anwendung angezeigt:
Bewegen Sie den Mauszeiger in das Anwendungsfenster, und drücken Sie anschließend eine Taste, um den Breakpoint auszulösen. Durch den Breakpoint wird Visual Studio wieder im Vordergrund angezeigt, und der Editor zeigt die Zeile an, in der die Ausführung pausiert wurde. Sie können die Variablen, Objekte, Threads und den Speicher der Anwendung untersuchen oder Ihren Code interaktiv in Einzelschritten durchlaufen. Klicken Sie auf Fortfahren, damit die Anwendung fortgesetzt wird, und beenden Sie sie dann auf herkömmliche Weise. Alternativ können Sie die Ausführung in Visual Studio mithilfe der Stoppschaltfläche anhalten.

Hinzufügen einer Linux-Konfiguration und Verbinden mit dem Remotecomputer

Fügen Sie eine Linux-Konfiguration hinzu. Klicken Sie mit der rechten Maustaste im Projektmappen-Explorer auf die Datei „CMakeSettings.json“, und wählen Sie Konfiguration hinzufügen aus. Das Dialogfeld „Konfiguration zu CMakeSettings hinzufügen“ wird geöffnet, das Sie schon aus dem vorherigen Schritt kennen. Wählen Sie dieses Mal Linux-Debug aus, und speichern (STRG + S) Sie die Datei „CMakeSettings.json“.
Visual Studio 2019, Version 16.6 oder höher Scrollen Sie im CMake-Einstellungs-Editor ganz nach unten, und wählen Sie Erweiterte Einstellungen anzeigen aus. Wählen Sie Unix Makefiles als CMake-Generator aus, und speichern Sie die Datei „CMakeSettings.json“ (STRG+S).
Wählen Sie Linux-Debug aus dem Dropdownmenü aus.

Wenn Sie zum ersten Mal eine Verbindung mit einem Linux-System herstellen, wird das Dialogfeld Mit Remotesystem verbinden angezeigt.

Das Dialogfeld enthält Felder für den Hostnamen, den Port, den Benutzernamen, den Authentifizierungstyp und das Kennwort. Alle Felder sind leer, außer Port ist auf 22 festgelegt, und der Authentifizierungstyp ist auf "Kennwort" festgelegt.

Wenn Sie bereits eine Remoteverbindung hinzugefügt haben, können Sie dieses Fenster öffnen, indem Sie zu tools > options > cross platform > Verbindungs-Manager navigieren.
Geben Sie die Verbindungsinformationen Ihres Linux-Computers ein, und klicken Sie anschließend auf Verbinden. Visual Studio fügt diesen Computer in „CMakeSettings.json“ als Standardverbindung für Linux-Debug hinzu. Außerdem werden die Header von Ihrem Remotecomputer abgerufen, damit Sie spezifische IntelliSense-Funktionen für diese Remoteverbindung verwenden können. Anschließend sendet Visual Studio Ihre Dateien an den Remotecomputer und generiert den CMake-Cache auf dem Remotesystem. Diese Schritte können je nach Geschwindigkeit Ihres Netzwerks und der Leistung Ihres Remotecomputers einige Zeit in Anspruch nehmen. Sie wissen, dass die Meldung "Zielinformationenextraktion abgeschlossen" im CMake-Ausgabefenster angezeigt wird.

Festlegen eines Breakpoints, Erstellen und Ausführen unter Linux

Da es sich um eine Desktopanwendung ist, müssen Sie der Debugkonfiguration einige weitere Konfigurationsinformationen bereitstellen.

Klicken Sie in der CMake-Zielansicht mit der rechten Maustaste auf „AppBasicExampleGui“, und wählen Sie Einstellungen für Debuggen und Starten aus, um die Datei „launch.vs.json“ zu öffnen, die sich im versteckten .vs-Unterordner befindet. Diese Datei befindet sich lokal in Ihrer Entwicklungsumgebung. Sie können sie zum Stamm Ihres Projekts verschieben, wenn Sie sie bei Ihrem Team einchecken und speichern möchten. In dieser Datei wurde eine Konfiguration für „AppBasicExampleGui“ hinzugefügt. Diese Standardeinstellungen funktionieren in den meisten Fällen, jedoch nicht in diesem Fall. Da es sich hier um eine Desktopanwendung handelt, müssen Sie zusätzliche Informationen zum Starten des Programms angeben, damit es auf Ihrem Linux-Computer angezeigt wird.
Führen Sie den folgenden Befehl aus, um den Wert für die Umgebungsvariable DISPLAY auf Ihrem Linux-Computer zu finden:
```
echo $DISPLAY
```
In der Konfiguration für „AppBasicExampleGui“ gibt es das Parameterarray „pipeArgs“. Dieses enthält die Zeile: „${debuggerCommand}“. Es ist der Befehl, der auf dem Remotecomputer gestartet wird gdb . Visual Studio muss die Anzeige in diesen Kontext exportieren, bevor dieser Befehl ausgeführt wird. Wenn der Wert Ihrer Anzeige beispielsweise :1 ist, passen Sie die Zeile wie folgt an:
```
"export DISPLAY=:1;${debuggerCommand}",
```
Starten und debuggen Sie Ihre Anwendung. Öffnen Sie das Dropdownmenü Startelement auswählen in der Symbolleiste, und wählen Sie dann AppBasicExampleGui aus. Klicken Sie dann auf das grüne Wiedergabesymbol in der Symbolleiste, oder drücken Sie F5. Die Anwendung und ihre Abhängigkeiten werden auf dem Linux-Remotecomputer erstellt und dann mit angefügtem Visual Studio-Debugger gestartet. Auf Ihrem Linux-Remotecomputer sollte ein Anwendungsfenster geöffnet werden.
Bewegen Sie Ihren Mauszeiger in das Anwendungsfenster, und drücken Sie eine Taste. Daraufhin wird der Breakpoint erreicht. Die Ausführung des Programms wird am Breakpoint angehalten, und Visual Studio wird wieder im Vordergrund angezeigt. Außerdem sollte ein Linux-Konsolenfenster in Visual Studio angezeigt werden. In diesem Fenster wird die Ausgabe des Linux-Computers angezeigt, und es kann auch Eingaben für stdin akzeptieren. Dieses Fenster können Sie wie jedes andere Visual Studio-Fenster wie gewünscht andocken. Die Position des Fensters wird in zukünftigen Sitzungen beibehalten.

Die Ausgabe im Fenster gibt an, dass die mit dlopen/dlsym dynamisch geladenen C11-Funktionen OK ist, ein GL 3.0-Kontext erstellt und der Direct GLX-Renderingkontext abgerufen und aktuell gemacht wurde. Das Fenster enthält verschiedene Versionsinformationen für GL_VENDOR, GL_VERSION, GL_SHADING_LANGUAGE_VERSION usw.
Sie können sich die Variablen, Objekte, Threads und den Arbeitsspeicher der Anwendung ansehen und Ihren Code in Visual Studio schrittweise und interaktiv ausführen. Dieses Mal führen Sie diese Schritt jedoch auf einem Linux-Remotecomputer statt in einer lokalen Windows-Umgebung aus. Sie können "Weiter" auswählen, damit die Anwendung normal fortgesetzt und beendet wird, oder Sie können die Stoppschaltfläche wie bei der lokalen Ausführung auswählen.
Sehen Sie sich das Aufruflistenfenster an, und zeigen Sie die Aufrufe von x11OpenGLWindow seit dem Start der Anwendung durch Visual Studio auf dem Linux-Computer an.

Der Callstack zeigt den Haltepunkt auf CommonRigidBodyBase::mouseMoveCallback und die Aufrufe an, die ihm vorangehen, z. B. OnMouseMove, X11OpenGLWindow::p umpMessage usw.

Vermittelte Inhalte

In diesem Tutorial haben Sie eine Codebasis direkt von GitHub geklont. Diese haben Sie ohne Änderungen unter Windows erstellt, ausgeführt und gedebuggt. Dieselbe Codebasis haben Sie dann mit geringfügigen Änderungen an der Konfiguration auf einem Linux-Remotecomputer erstellt, ausgeführt und gedebuggt.

Nächste Schritte

In den folgenden Artikeln erhalten Sie weitere Informationen zum Konfigurieren und Debuggen von CMake-Projekten in Visual Studio:

CMake Projects in Visual Studio (CMake-Projekte in Visual Studio)

Konfigurieren eines Linux CMake-Projekts

Herstellen einer Verbindung mit Ihrem Linux-Remotecomputer

Anpassen von CMake-Buildeinstellungen

Konfigurieren von CMake-Debugsitzungen

Bereitstellen, Ausführen und Debuggen Ihres Linux-Projekts

Vordefinierte Konfigurationsreferenz für CMake in CMake-Projekten Installieren und Verwenden von Paketen mit CMake in Visual Studio