Tutoriel : Installer et utiliser des packages avec CMake dans Visual Studio

Article
26/09/2024

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

Prérequis

Visual Studio avec la charge de travail de développement C++ et le composant CMake
Git

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 :

Console
```
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 :
Console
```
cd vcpkg && bootstrap-vcpkg.bat
```
Console
```
cd vcpkg; .\bootstrap-vcpkg.bat
```
Console
```
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 Visual Studio

Créer le projet Visual Studio
- Créer un projet dans Visual Studio à l’aide du modèle « Projet CMake »
Capture d’écran de l’interface utilisateur de Visual Studio pour montrer comment créer un projet CMake dans Visual Studio
- Nommez votre projet « helloworld »
- Cochez la case « Placer la solution et le projet dans le même répertoire ».
- Cliquez sur le bouton « Créer »
Capture d’écran de l’interface utilisateur de Visual Studio pour nommer votre projet CMake et cliquer sur le bouton « Créer ».
Configurez la variable d’environnement VCPKG_ROOT.

Notes

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.
Ouvrez la fenêtre PowerShell développeur intégrée dans Visual Studio.

Capture d’écran de l’interface utilisateur de Visual Studio pour la fenêtre de développement PowerShell intégrée

Exécutez les commandes suivantes :

PowerShell
```
$env:VCPKG_ROOT="C:\path\to\vcpkg"
$env:PATH="$env:VCPKG_ROOT;$env:PATH"
```
Capture d’écran de l’interface utilisateur de Visual Studio pour la fenêtre de développeur PowerShell intégrée montrant comment configurer VCPKG_ROOT et l’ajouter à PATH.
Ouvrez l’invite de commandes Développeur dans Visual Studio.

Capture d’écran de l’invite de commandes Visual Studio UI pour développeur.

Exécutez les commandes suivantes :

Console
```
set "VCPKG_ROOT=C:\path\to\vcpkg"
set PATH=%VCPKG_ROOT%;%PATH%
```
Capture d’écran de l’invite de commandes du développeur Visual Studio montrant comment configurer VCPKG_ROOT et l’ajouter à PATH.
Le paramètre VCPKG_ROOT aide Visual Studio à localiser 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.
Générez un fichier manifeste et ajoutez des dépendances.

Exécutez la commande suivante pour créer un fichier manifeste vcpkg (vcpkg.json) :

Console
```
vcpkg new --application
```
La vcpkg new commande ajoute un vcpkg.json fichier et un vcpkg-configuration.json fichier dans le répertoire du projet.

Ajoutez le fmt package en tant que dépendance :

Console
```
vcpkg add port fmt
```
Votre vcpkg.json doit maintenant contenir :

JSON
```
{
    "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 généré vcpkg-configuration.json introduit une base de référence qui place les contraintes de version minimales sur les dépendances du projet. La modification de ce fichier dépasse le cadre de ce didacticiel. Bien qu’il ne soit pas applicable dans ce didacticiel, il est recommandé de conserver le fichier sous contrôle de code source pour garantir la vcpkg-configuration.json cohérence des versions dans différents environnements de développement.

3 - Configurer les fichiers projet

Modifiez le fichier helloworld.cpp.

Remplacez le contenu du helloworld.cpp code suivant :

C++
```
#include <fmt/core.h>

int main()
{
    fmt::print("Hello World!\n");
    return 0;
}
```
Ce fichier source inclut l’en-tête <fmt/core.h> qui fait partie de la fmt bibliothèque. La main() fonction appelle fmt::print() pour générer le message « Hello World ! » dans la console.
Configurez le CMakePresets.json fichier.

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.

Modifiez CMakePresets.json pour correspondre au contenu ci-dessous :

JSON
```
{
  "version": 2,
  "configurePresets": [
    {
      "name": "vcpkg",
      "generator": "Ninja",
      "binaryDir": "${sourceDir}/build",
      "cacheVariables": {
        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
      }
    }
  ]
}
```
Créez CMakeUserPresets.json avec le contenu suivant :

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.
Modifiez le fichier CMakeLists.txt.

Remplacez le contenu du fichier CMakeLists.txt par le code suivant :

cmake
```
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, la build échoue.
- 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.

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

Créez le projet.

Appuyez Ctrl+Shift+B pour générer le projet dans Visual Studio.
Exécutez l'application.

Enfin, exécutez l’exécutable :

Capture d’écran de l’interface utilisateur de Visual Studio pour l’exécution de l’exécutable.

La sortie suivante doit s'afficher :

Capture d’écran des sorties du programme - « Hello World ! »

Étapes suivantes

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

Partager via