Tutoriel : Installer et utiliser des packages avec CMake

Article
09/26/2024

Ce tutoriel vous montre comment créer un programme « Hello World » C++ qui utilise la fmt bibliothèque avec CMake et vcpkg. Vous allez installer des dépendances, configurer, générer et exécuter une application simple.

Prérequis

Un terminal
Compilateur C++
CMake
Git

Remarque

Pour les utilisateurs Windows, le compilateur MSVC de Visual Studio (Microsoft Visual C++) est le compilateur requis pour le développement C++.

1 - Configurer vcpkg

Cloner le référentiel

La première étape consiste à cloner le référentiel vcpkg à partir de GitHub. Le référentiel contient des scripts pour acquérir l’exécutable vcpkg et un registre de bibliothèques open source organisées gérées par la communauté vcpkg. Pour ce faire, exécutez :
```
git clone https://github.com/microsoft/vcpkg.git
```
Le registre organisé vcpkg est un ensemble de plus de 2 000 bibliothèques open source. Ces bibliothèques ont été validées par les pipelines d’intégration continue de vcpkg pour fonctionner ensemble. Bien que le référentiel vcpkg ne contienne pas le code source de ces bibliothèques, il contient des recettes et des métadonnées pour les générer et les installer dans votre système.
Exécuter le script bootstrap

Maintenant que vous avez cloné le référentiel vcpkg, accédez au vcpkg répertoire et exécutez le script de démarrage :
```
cd vcpkg && bootstrap-vcpkg.bat
```
```
cd vcpkg; .\bootstrap-vcpkg.bat
```
```
cd vcpkg && ./bootstrap-vcpkg.sh
```
Le script d’amorçage effectue des vérifications des prérequis et télécharge l’exécutable vcpkg.

Et voilà ! vcpkg est configuré et prêt à être utilisé.

2 - Configurer le projet

Configurez la variable d’environnement VCPKG_ROOT.
```
export VCPKG_ROOT=/path/to/vcpkg
export PATH=$VCPKG_ROOT:$PATH
```
Remarque

La définition de variables d’environnement à l’aide de la export commande affecte uniquement la session shell active. Pour rendre cette modification permanente entre les sessions, ajoutez la export commande au script de profil de votre interpréteur de commandes (par exemple, ~/.bashrc ou ~/.zshrc).
```
set "VCPKG_ROOT=C:\path\to\vcpkg"
set PATH=%VCPKG_ROOT%;%PATH%
```
Remarque

La définition de variables d’environnement de cette façon affecte uniquement la session de terminal active. Pour rendre ces modifications permanentes dans toutes les sessions, définissez-les via le panneau Variables d’environnement système Windows.
```
$env:VCPKG_ROOT = "C:\path\to\vcpkg"
$env:PATH = "$env:VCPKG_ROOT;$env:PATH"
```
Remarque

La définition de variables d’environnement de cette façon affecte uniquement la session de terminal active. Pour rendre ces modifications permanentes dans toutes les sessions, définissez-les via le panneau Variables d’environnement système Windows.
Le paramètre VCPKG_ROOT indique à vcpkg où se trouve votre instance vcpkg. L’ajout de ces commandes vous PATH permet d’exécuter des commandes vcpkg directement à partir de l’interpréteur de commandes.
Créez le répertoire du projet.
```
mkdir helloworld && cd helloworld
```

3 - Ajouter des dépendances et des fichiers projet

Créez le fichier manifeste et ajoutez la fmt dépendance.

Tout d’abord, créez un fichier manifeste (vcpkg.json) dans le répertoire de votre projet en exécutant la vcpkg new commande à partir du helloworld répertoire :
```
vcpkg new --application
```
Ensuite, ajoutez la fmt dépendance :
```
vcpkg add port fmt
```
Votre vcpkg.json doit ressembler à ceci :
```
{
    "dependencies": [
        "fmt"
    ]
}
```
Il s’agit de votre fichier manifeste. vcpkg lit le fichier manifeste pour savoir quelles dépendances installer et intégrer avec CMake pour fournir les dépendances requises par votre projet.

Le fichier par défaut vcpkg-configuration.json introduit des contraintes de base, en spécifiant les versions minimales des dépendances que votre projet doit utiliser. Bien que la modification de ce fichier dépasse la portée de ce didacticiel, elle joue un rôle crucial dans la définition des contraintes de version pour les dépendances de votre projet. Par conséquent, même s’il n’est pas strictement nécessaire pour ce didacticiel, il est recommandé d’ajouter vcpkg-configuration.json à votre contrôle de code source pour garantir la cohérence des versions dans différents environnements de développement.
Créez les fichiers projet.

Créez le CMakeLists.txt fichier avec le contenu suivant :
```
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)
```
Maintenant, nous allons décomposer ce que fait chaque ligne du CMakeLists.txt fichier :
- cmake_minimum_required(VERSION 3.10): spécifie que la version minimale de CMake requise pour générer le projet est 3.10. Si la version de CMake installée sur votre système est inférieure à celle-ci, une erreur est générée.
- project(HelloWorld): définit le nom du projet sur « HelloWorld ».
- find_package(fmt CONFIG REQUIRED): recherche la bibliothèque à l’aide de fmt son fichier de configuration CMake. Le REQUIRED mot clé garantit qu’une erreur est générée si le package est introuvable.
- add_executable(HelloWorld helloworld.cpp): ajoute une cible exécutable nommée « HelloWorld », générée à partir du fichier helloworld.cppsource.
- target_link_libraries(HelloWorld PRIVATE fmt::fmt): spécifie que l’exécutable HelloWorld doit être lié à la fmt bibliothèque. Le PRIVATE mot clé indique qu’il fmt est uniquement nécessaire pour la génération HelloWorld et ne doit pas se propager à d’autres projets dépendants.
Créez le helloworld.cpp fichier avec le contenu suivant :
```
#include <fmt/core.h>

int main()
{
    fmt::print("Hello World!\n");
    return 0;
}
```
Dans ce helloworld.cpp fichier, l’en-tête <fmt/core.h> est inclus pour l’utilisation de la fmt bibliothèque. La main() fonction appelle fmt::print() ensuite pour générer le message « Hello World ! » dans la console.

4 - Générer et exécuter le projet

Exécuter la configuration CMake

CMake peut lier automatiquement des bibliothèques installées par vcpkg quand elle CMAKE_TOOLCHAIN_FILE est définie pour utiliser la chaîne d’outils personnalisée de vcpkg. Cela peut être acomplishé à l’aide de fichiers préréglages CMake.

Créez les fichiers suivants dans le helloworld répertoire :

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>"
        }
      }
    ]
  }
```
Le CMakePresets.json fichier contient une présélection unique nommée « vcpkg », qui définit la CMAKE_TOOLCHAIN_FILE variable. Le CMakeUserPresets.json fichier définit la VCPKG_ROOT variable d’environnement pour qu’elle pointe vers le chemin absolu contenant votre installation locale de vcpkg. Il est recommandé de ne pas vérifier CMakeUserPresets.json les systèmes de contrôle de version.

Enfin, configurez la build à l’aide de CMake :
```
cmake --preset=default
```
Créer le projet

Run :
```
cmake --build build
```
Exécution de l'application

Enfin, exécutez l’exécutable pour voir votre application en action :
```
./build/HelloWorld

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

Hello World!
```

Partager via