Lernprogramm: Installieren und Verwenden von Paketen mit CMake

Artikel
09/26/2024

In diesem Lernprogramm erfahren Sie, wie Sie ein C++-Programm "Hallo Welt" erstellen, das die fmt Bibliothek mit CMake und vcpkg verwendet. Sie installieren Abhängigkeiten, konfigurieren, erstellen und führen eine einfache Anwendung aus.

Voraussetzungen

Ein Terminal
einen C++-Compiler
CMake
Git

Hinweis

Für Windows-Benutzer ist der MSVC (Microsoft Visual C++-Compiler) von Visual Studio der erforderliche Compiler für die C++-Entwicklung.

1 – Einrichten von vcpkg

Klonen des Repositorys

Der erste Schritt besteht darin, das vcpkg-Repository von GitHub zu klonen. Das Repository enthält Skripts zum Abrufen der ausführbaren Datei vcpkg und eine Registrierung kuratierter Open-Source-Bibliotheken, die von der vcpkg-Community verwaltet werden. Führen Sie dazu Folgendes aus:
```
git clone https://github.com/microsoft/vcpkg.git
```
Die kuratierte vcpkg-Registrierung ist eine Reihe von mehr als 2.000 Open-Source-Bibliotheken. Diese Bibliotheken wurden von den kontinuierlichen Integrationspipelines von vcpkg überprüft, um zusammenzuarbeiten. Während das vcpkg-Repository nicht den Quellcode für diese Bibliotheken enthält, enthält es Rezepte und Metadaten zum Erstellen und Installieren in Ihrem System.
Ausführen des Bootstrap-Skripts

Nachdem Sie das vcpkg-Repository geklont haben, navigieren Sie zum vcpkg Verzeichnis, und führen Sie das Bootstrap-Skript aus:
```
cd vcpkg && bootstrap-vcpkg.bat
```
```
cd vcpkg; .\bootstrap-vcpkg.bat
```
```
cd vcpkg && ./bootstrap-vcpkg.sh
```
Das Bootstrap-Skript führt erforderliche Prüfungen durch und lädt die ausführbare Datei vcpkg herunter.

Das ist alles! vcpkg ist eingerichtet und einsatzbereit.

2 – Einrichten des Projekts

Konfigurieren Sie die Umgebungsvariable VCPKG_ROOT.
```
export VCPKG_ROOT=/path/to/vcpkg
export PATH=$VCPKG_ROOT:$PATH
```
Hinweis

Das Festlegen von Umgebungsvariablen mit dem export Befehl wirkt sich nur auf die aktuelle Shellsitzung aus. Um diese Änderung dauerhaft in Sitzungen vorzunehmen, fügen Sie den export Befehl zum Profilskript Ihrer Shell hinzu (z. B ~/.bashrc . oder ~/.zshrc).
```
set "VCPKG_ROOT=C:\path\to\vcpkg"
set PATH=%VCPKG_ROOT%;%PATH%
```
Hinweis

Das Festlegen von Umgebungsvariablen auf diese Weise wirkt sich nur auf die aktuelle Terminalsitzung aus. Um diese Änderungen in allen Sitzungen dauerhaft vorzunehmen, legen Sie sie über den Bereich "Windows System Environment Variables" fest.
```
$env:VCPKG_ROOT = "C:\path\to\vcpkg"
$env:PATH = "$env:VCPKG_ROOT;$env:PATH"
```
Hinweis

Das Festlegen von Umgebungsvariablen auf diese Weise wirkt sich nur auf die aktuelle Terminalsitzung aus. Um diese Änderungen in allen Sitzungen dauerhaft vorzunehmen, legen Sie sie über den Bereich "Windows System Environment Variables" fest.
Die Einstellung VCPKG_ROOT teilt vcpkg mit, wo sich Ihre vcpkg-Instanz befindet. PATH Durch das Hinzufügen wird sichergestellt, dass Sie vcpkg-Befehle direkt über die Shell ausführen können.
Erstellen Sie das Projektverzeichnis.
```
mkdir helloworld && cd helloworld
```

3 – Hinzufügen von Abhängigkeiten und Projektdateien

Erstellen Sie die Manifestdatei, und fügen Sie die fmt Abhängigkeit hinzu.

Erstellen Sie zunächst eine Manifestdatei (vcpkg.json) im Verzeichnis Ihres Projekts, indem Sie den vcpkg new Befehl aus dem helloworld Verzeichnis ausführen:
```
vcpkg new --application
```
Fügen Sie als Nächstes die fmt Abhängigkeit hinzu:
```
vcpkg add port fmt
```
Ihr App-Modul (vcpkg.json) sollte wie folgt aussehen:
```
{
    "dependencies": [
        "fmt"
    ]
}
```
Dies ist Ihre Manifestdatei. vcpkg liest die Manifestdatei, um zu erfahren, welche Abhängigkeiten installiert und in CMake integriert werden sollen, um die für Ihr Projekt erforderlichen Abhängigkeiten bereitzustellen.

In der Standarddatei vcpkg-configuration.json werden Basislinieneinschränkungen eingeführt, wobei die Mindestversionen von Abhängigkeiten angegeben werden, die ihr Projekt verwenden sollte. Während das Ändern dieser Datei außerhalb des Umfangs dieses Lernprogramms liegt, spielt sie eine wichtige Rolle bei der Definition von Versionsbeschränkungen für die Abhängigkeiten Ihres Projekts. Daher empfiehlt es sich, Ihrer Quellcodeverwaltung hinzuzufügen vcpkg-configuration.json , auch wenn es für dieses Lernprogramm nicht unbedingt erforderlich ist, um die Versionskonsistenz in verschiedenen Entwicklungsumgebungen sicherzustellen.
Erstellen Sie die Projektdateien.

Erstellen Sie die CMakeLists.txt Datei mit dem folgenden Inhalt:
```
cmake_minimum_required(VERSION 3.10)

project(HelloWorld)

find_package(fmt CONFIG REQUIRED)

add_executable(HelloWorld helloworld.cpp)

target_link_libraries(HelloWorld PRIVATE fmt::fmt)
```
Lassen Sie uns nun die Funktionsweise jeder Zeile in der CMakeLists.txt Datei aufschlüsseln:
- cmake_minimum_required(VERSION 3.10): Gibt an, dass die zum Erstellen des Projekts erforderliche Mindestversion von CMake 3.10 ist. Wenn die auf Ihrem System installierte CMake-Version niedriger ist als dies, wird ein Fehler generiert.
- project(HelloWorld): Legt den Namen des Projekts auf "HelloWorld" fest.
- find_package(fmt CONFIG REQUIRED): Sucht anhand der CMake-Konfigurationsdatei nach der fmt Bibliothek. Das REQUIRED Schlüsselwort stellt sicher, dass ein Fehler generiert wird, wenn das Paket nicht gefunden wird.
- add_executable(HelloWorld helloworld.cpp): Fügt ein ausführbares Ziel namens "HelloWorld" hinzu, das aus der Quelldatei helloworld.cpperstellt wurde.
- target_link_libraries(HelloWorld PRIVATE fmt::fmt): Gibt an, dass die HelloWorld ausführbare Datei mit der fmt Bibliothek verknüpft werden soll. Das PRIVATE Schlüsselwort gibt an, dass fmt nur für das Erstellen HelloWorld erforderlich ist und nicht an andere abhängige Projekte weitergegeben werden soll.
Erstellen Sie die helloworld.cpp Datei mit dem folgenden Inhalt:
```
#include <fmt/core.h>

int main()
{
    fmt::print("Hello World!\n");
    return 0;
}
```
In dieser helloworld.cpp Datei ist der <fmt/core.h> Header für die Verwendung der fmt Bibliothek enthalten. Die main() Funktion ruft fmt::print() dann auf, um die Meldung "Hallo Welt!" an die Konsole auszugeben.

4 – Erstellen und Ausführen des Projekts

Ausführen der CMake-Konfiguration

CMake kann Bibliotheken, die von vcpkg installiert werden, automatisch verknüpfen, wenn CMAKE_TOOLCHAIN_FILE die benutzerdefinierte Toolkette von vcpkg verwendet wird. Dies kann mithilfe von CMake-Voreinstellungen erstellt werden.

Erstellen Sie die folgenden Dateien im helloworld Verzeichnis:

CMakePresets.json
```
{
  "version": 2,
  "configurePresets": [
    {
      "name": "vcpkg",
      "generator": "Ninja",
      "binaryDir": "${sourceDir}/build",
      "cacheVariables": {
        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
      }
    }
  ]
}
```
CMakeUserPresets.json
```
{
    "version": 2,
    "configurePresets": [
      {
        "name": "default",
        "inherits": "vcpkg",
        "environment": {
          "VCPKG_ROOT": "<path to vcpkg>"
        }
      }
    ]
  }
```
Die CMakePresets.json Datei enthält eine einzelne Voreinstellung namens "vcpkg", die die CMAKE_TOOLCHAIN_FILE Variable festlegt. Die CMakeUserPresets.json Datei legt die VCPKG_ROOT Umgebungsvariable so fest, dass sie auf den absoluten Pfad zeigt, der Die lokale Installation von vcpkg enthält. Es wird empfohlen, keine Versionskontrollsysteme zu überprüfen CMakeUserPresets.json .

Konfigurieren Sie schließlich den Build mit CMake:
```
cmake --preset=default
```
Erstellen des Projekts

Führen Sie Folgendes aus:
```
cmake --build build
```
Ausführen der Anwendung

Führen Sie schließlich die ausführbare Datei aus, um ihre Anwendung in Aktion zu sehen:
```
./build/HelloWorld

Hello World!
```
```
.\build\HelloWorld.exe

Hello World!
```

Freigeben über