Tutoriel : Installer et utiliser des packages avec vcpkg

Article
05/01/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 bootstrap effectue les case activée 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 main.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. La REQUIRED mot clé garantit qu’une erreur est générée si le package est introuvable.
- add_executable(HelloWorld main.cpp): ajoute une cible exécutable nommée « HelloWorld », générée à partir du fichier main.cppsource.
- target_link_libraries(HelloWorld PRIVATE fmt::fmt): spécifie que l’exécutable HelloWorld doit être lié à la fmt bibliothèque. La PRIVATE mot clé indique qu’elle fmt est uniquement nécessaire pour la création HelloWorld et ne doit pas se propager à d’autres projets dépendants.
Créez le main.cpp fichier avec le contenu suivant :
```
#include <fmt/core.h>

int main()
{
    fmt::print("Hello World!\n");
    return 0;
}
```
Dans ce main.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

Pour permettre au système de projet CMake de reconnaître les bibliothèques C++ fournies par vcpkg, vous devez fournir le vcpkg.cmake fichier de chaîne d’outils. Pour automatiser cela, créez un CMakePresets.json fichier dans le répertoire « helloworld » avec le contenu suivant :
```
{
  "version": 2,
  "configurePresets": [
    {
      "name": "default",
      "generator": "Ninja",
      "binaryDir": "${sourceDir}/build",
      "cacheVariables": {
        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
      }
    }
  ]
}
```
Ce CMakePresets.json fichier contient une présélection « par défaut » unique pour CMake et définit la CMAKE_TOOLCHAIN_FILE variable. Le CMAKE_TOOLCHAIN_FILE système de projet CMake permet de reconnaître les bibliothèques C++ fournies par vcpkg. L’ajout de l’outil CMakePresets.json automatise le processus de spécification de la chaîne d’outils lors de l’exécution de CMake.

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!
```

Étapes suivantes

Pour en savoir plus sur vcpkg.json, consultez notre documentation de référence :

Partager via