Configurer et générer avec CMake Presets dans Visual Studio

  • Article

CMake prend en charge deux fichiers qui permettent aux utilisateurs de spécifier des options courantes de configuration, de génération et de test, et de les partager avec d’autres utilisateurs : CMakePresets.json et CMakeUserPresets.json. Utilisez ces fichiers pour piloter CMake dans Visual Studio et Visual Studio Code, dans un pipeline d’intégration continue (CI) et à partir de la ligne de commande.

CMakePresets.json permet d’enregistrer des builds à l’échelle du projet. CMakeUserPresets.json est destiné aux développeurs d’enregistrer leurs propres builds locales. Les deux fichiers sont pris en charge dans Visual Studio 2019 version 16.10 ou ultérieure.

Cet article contient des informations sur l’intégration CMakePresets.json à Visual Studio. Voici des liens utiles :

Nous vous recommandons CMakePresets.json d’utiliser une alternative à CMakeSettings.json. Visual Studio ne lit jamais les deux CMakePresets.json et CMakeSettings.json en même temps. Pour activer ou désactiver CMakePresets.json l’intégration dans Visual Studio, consultez Activer CMakePresets.json dans Visual Studio 2019.

Prise en charge de CMake et CMakePresets.json de versions

Les versions prises en charge CMakePresets.json et CMakeUserPresets.json de schéma dépendent de votre version de Visual Studio :

  • Visual Studio 2019 version 16.10 et versions ultérieures prennent en charge les versions de schéma 2 et 3.
  • Visual Studio 2022 version 17.4 preview 1 ajoute la prise en charge du schéma version 4.
  • Visual Studio 2022 version 17.5 preview 1 ajoute la prise en charge du schéma version 5.

Vous pouvez mettre à jour la version en modifiant le "version" champ dans l’objet racine. Pour obtenir un exemple et plus d’informations, consultez CMakePresets.json le format.

CMake version 3.20 ou ultérieure est nécessaire lorsque vous appelez CMake à CMakePresets.json partir de la ligne de commande. Toutefois, Visual Studio lit et évalue CMakePresets.json et CMakeUserPresets.json n’appelle pas CMake directement avec l’option --preset . Par conséquent, CMake version 3.20 ou ultérieure n’est pas strictement nécessaire lorsque vous générez à CMakePresets.json l’intérieur de Visual Studio.

Nous vous recommandons d’utiliser au moins CMake version 3.14 ou ultérieure.

Activer CMakePresets.json l’intégration dans Visual Studio

CMakePresets.json l’intégration n’est pas activée par défaut dans Visual Studio. Vous pouvez l’activer dans Options>outils>CMake>Général :

Screenshot showing 'Always use CMakePresets.json' selected.

Important

Fermez et rouvrez le dossier dans Visual Studio pour activer l’intégration.

Dans certaines versions antérieures de Visual Studio, Les options>outils>CMake>Général n’ont qu’une seule option pour activer CMakePresets.json l’intégration :

Screenshot of an older version of Visual Studio. There is a checkbox labeled 'Use C Make Presets .json to drive CMake configure, build, and test.'

Le tableau suivant indique quand CMakePresets.json est utilisé au lieu de CMakeSettings.json piloter la configuration CMake et la génération dans Visual Studio 2022 et Visual Studio 2019 version 16.10 et versions ultérieures. Si aucun fichier de configuration n’est présent, la configuration par défaut des présélections est utilisée.

Dans le tableau, « Options d’outils>activées » signifie Utiliser CMakePresets.json pour piloter la configuration, la génération et le test CMake sont sélectionnés dans Outils>Options>CMake>Général.

Fichiers de configuration Options d’outils > désactivées Options d’outils > activées
Aucun fichier de configuration présent CMakeSettings.json CMakePresets.json
CMakeSettings.json Présent CMakeSettings.json CMakePresets.json
CMakePresets.json Présent CMakePresets.json CMakePresets.json
Les deux fichiers de configuration sont présents CMakePresets.json CMakePresets.json

Modifier la configuration automatique et les notifications de cache

Par défaut, Visual Studio appelle automatiquement chaque fois que le système cible actif ou configure les modifications prédéfinies configure . Vous pouvez modifier ce comportement en sélectionnant Ne jamais exécuter l’étape de configuration automatiquement dans Options>outils>CMake>Général. Vous pouvez également désactiver toutes les notifications de cache CMake (barres d’or) en désactivant les notifications de cache CMake.

Configuration par défaut des présélections

S’il n’existe aucun CMakePresets.jsonCMakeUserPresets.json ou fichier ou s’il CMakePresets.json n’est pas CMakeUserPresets.json valide, Visual Studio revient sur les présélections de configuration par défaut suivantes :

Exemple Windows

{
  "name": "windows-default",
  "displayName": "Windows x64 Debug",
  "description": "Sets Ninja generator, compilers, x64 architecture, build and install directory, debug build type",
  "generator": "Ninja",
  "binaryDir": "${sourceDir}/out/build/${presetName}",
  "architecture": {
    "value": "x64",
    "strategy": "external"
  },
  "cacheVariables": {
    "CMAKE_BUILD_TYPE": "Debug",
    "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
  },
  "vendor": {
    "microsoft.com/VisualStudioSettings/CMake/1.0": {
      "hostOS": [ "Windows" ]
    }
  }
},

Exemple Linux

{
  "name": "linux-default",
  "displayName": "Linux Debug",
  "description": "Sets Ninja generator, compilers, build and install directory, debug build type",
  "generator": "Ninja",
  "binaryDir": "${sourceDir}/out/build/${presetName}",
  "cacheVariables": {
    "CMAKE_BUILD_TYPE": "Debug",
    "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
  },
  "vendor": {
    "microsoft.com/VisualStudioSettings/CMake/1.0": {
      "hostOS": [ "Linux" ]
    },
    "microsoft.com/VisualStudioRemoteSettings/CMake/1.0": {
      "sourceDir": "$env{HOME}/.vs/$ms{projectDirName}"
   }
  }
}

Si vous essayez d’ouvrir ou de modifier un CMakePresets.json fichier qui n’existe pas, Visual Studio crée automatiquement un CMakePresets.json fichier avec la configuration par défaut des présélections à la racine de votre projet.

Configurer et générer

Dans la barre d’outils Visual Studio, il existe des listes déroulantes pour les systèmes cibles, configurer des présélections et générer des présélections lorsque CMakePresets.json l’intégration est activée :

Screenshot showing the dropdowns for target system set to Local Machine, configuration set to windows-arm64, and build preset set to default.

Sélectionner un système cible

La liste déroulante à gauche indique le système cible actif. Il s’agit du système sur lequel CMake est appelé pour configurer et générer le projet. Cette liste déroulante inclut votre ordinateur local, toutes les connexions SSH dans Connecter ion Manager par nom d’hôte et toutes les installations Sous-système Windows pour Linux (WSL) que Visual Studio peut trouver :

Screenshot of the Target System dropdown list

Dans l'exemple précédent :

  • 192.168.0.5 est un système Linux distant qui a été ajouté à Connecter ion Manager.
  • ubuntu2004 et debian sont des installations WSL.

Sélectionnez Gérer les Connecter ions pour ouvrir Connecter ion Manager.

Sélectionner une présélection de configuration

La liste déroulante au milieu indique la présélection de configuration active. Il s’agit de la configurePreset valeur utilisée lorsque CMake est appelé pour générer le système de génération de projet. Cette liste déroulante inclut l’union des présélections de configuration non masquées définies dans CMakePresets.json et CMakeUserPresets.json.

Visual Studio utilise la valeur de hostOS la carte microsoft Visual Studio Paramètres fournisseur pour masquer les présélections qui ne s’appliquent pas au système cible actif. Pour plus d’informations, consultez l’entrée de hostOS la table sous Visual Studio Paramètres carte fournisseur.

Sélectionnez Gérer les configurations pour ouvrir le CMakePresets.json fichier situé à la racine du projet. CMakePresets.json est créé s’il n’existe pas déjà.

Sélectionner une présélection de build

La liste déroulante à droite indique la présélection de build active. Il s’agit de la buildPreset valeur utilisée lorsque CMake est appelé pour générer le projet. Cette liste déroulante inclut l’union des présélections de build non masquées définies dans CMakePresets.json et CMakeUserPresets.json.

Toutes les présélections de build sont requises pour spécifier une valeur associée configurePreset . Visual Studio masque les présélections de build qui ne s’appliquent pas à la présélection de configuration active. Pour plus d’informations, consultez la liste des présélections de build.

S’il n’existe aucune présélection de build associée à la présélection de configuration active, Visual Studio répertorie la présélection de build par défaut. La présélection de build par défaut équivaut à passer cmake --build sans autres arguments de la ligne de commande.

Configurer

Visual Studio tente automatiquement de configurer le projet lorsqu’il détecte que le cache CMake est obsolète. Pour appeler manuellement la configuration, sélectionnez Project>Configure <project-name> dans le menu principal. Il est identique à l’exécution cmake --preset <configurePreset> à partir de la ligne de commande, où <configurePreset> est le nom de la présélection de configuration active.

Pour désactiver la génération automatique du cache, consultez La configuration automatique et les notifications de cache.

Build

Pour générer l’intégralité du projet, sélectionnez Générer>tout dans le menu principal. Il est identique à l’exécution cmake --build --preset <buildPreset> à partir de la ligne de commande, où <buildPreset> est le nom de la présélection de build active.

Pour générer une cible unique, basculez vers la vue Cibles CMake dans Explorateur de solutions. Cliquez ensuite avec le bouton droit sur n’importe quelle cible, puis sélectionnez Générer dans le menu contextuel.

Remarque

Visual Studio 2019 ne prend pas en charge l’option buildPresets.targets permettant de générer un sous-ensemble de cibles spécifiées dans CMakePresets.json.

Exécuter CTest

CMakePresets.json prend en charge deux options de menu dans Visual Studio 2019 :

  • Test>Run CTests for <project-name> appelle CTest et exécute tous les tests associés à la présélection de configuration active et à la présélection de build, sans autres arguments passés à CTest.
  • Test>Run Test Preset for <configurePreset> développe pour afficher toutes les présélections de test associées à la présélection de configuration active. La sélection d’une présélection de test unique est identique à l’exécution ctest --preset <testPreset> à partir de la ligne de commande, où <testPreset> est le nom de la présélection de test sélectionnée. Cette option n’est pas disponible si aucune présélection de test n’est définie pour la présélection de configuration active.

Dans Visual Studio 2019, l’Explorateur de tests n’est pas intégré à CMakePresets.json.

Ajouter de nouvelles présélections

Dans Visual Studio 2019, toutes les commandes et modèles prédéfinis modifient CMakePresets.json. Vous pouvez ajouter de nouvelles présélections au niveau de l’utilisateur en modifiant CMakeUserPresets.jsondirectement .

Utilisez une barre oblique (/) pour les chemins d’accès dans CMakePresets.json et CMakeUserPresets.json.

Ajouter de nouvelles présélections de configuration

Pour ajouter une nouvelle présélection de configuration à , à CMakePresets.jsonpartir de Explorateur de solutions, cliquez avec le bouton CMakePresets.json droit dans l’affichage dossier et sélectionnez Ajouter une configuration dans le menu contextuel. La boîte de dialogue pour sélectionner un modèle de présélection s’affiche :

Screenshot of the Add Configure Preset to the JSON file dialog. It contains entries such as Linux Debug, macOS Debug, x64 Debug, and so on.

Sélectionnez le modèle de débogage Windows x64 à configurer sur les systèmes Windows. Sélectionnez le modèle de débogage Linux à configurer sur les systèmes WSL et Linux distants. Pour plus d’informations sur la modification CMakePresets.json, consultez Modifier les présélections.

Le modèle sélectionné est ajouté s’il CMakePresets.json existe. Sinon, le modèle est copié dans un nouveau CMakePresets.json fichier.

Ajouter de nouvelles présélections de build et des présélections de test

Visual Studio 2019 n’offre pas de modèles pour les nouvelles présélections de build et les présélections de test. Vous pouvez ajouter des présélections de build et des présélections de test en modifiant CMakePresets.jsondirectement . Pour plus d’informations, consultez la liste des présélections de build, la liste des présélections de test ou un exemple CMakePresets.json de fichier.

Modifier les présélections

La documentation CMake officielle est la meilleure ressource pour modifier les présélections de configuration, les présélections de build et les présélections de test. Les informations suivantes sont un sous-ensemble de la documentation CMake particulièrement pertinente pour les développeurs Visual Studio.

Sélectionner vos compilateurs

Vous pouvez définir des compilateurs C et C++ à l’aide cacheVariables.CMAKE_C_COMPILER et cacheVariables.CMAKE_CXX_COMPILER dans une présélection de configuration. Il équivaut à passer -D CMAKE_C_COMPILER=<value> et -D CMAKE_CXX_COMPILER=<value> à CMake à partir de la ligne de commande. Pour plus d’informations, consultez CMAKE_<LANG>_COMPILER.

Utilisez les exemples suivants pour générer avec et clang-cl.exe à cl.exe partir de Visual Studio. Les outils C++ Clang pour les composants Windows doivent être installés pour vous permettre de générer avec clang-cl.

Générer avec cl.exe:

"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
  "CMAKE_C_COMPILER": "cl",
  "CMAKE_CXX_COMPILER": "cl"
},

Générer avec clang:

"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
  "CMAKE_C_COMPILER": "clang-cl",
  "CMAKE_CXX_COMPILER": "clang-cl"
},

"vendor": {
  "microsoft.com/VisualStudioSettings/CMake/1.0": {
    "intelliSenseMode": "windows-clang-x64"
  }
}

Si vous utilisez ou Visual Studio 16 2019Visual Studio 17 2022 comme générateur, vous pouvez utiliser la toolset présélection configurer pour spécifier l’ensemble d’outils ClangCL :

"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
},

"toolset": "ClangCL",

"vendor": {
  "microsoft.com/VisualStudioSettings/CMake/1.0": {
    "intelliSenseMode": "windows-clang-x64"
  }
}

Pour plus d’informations sur les générateurs qui prennent en charge la toolset spécification, consultez CMAKE_GENERATOR_TOOLSET la documentation CMake.

Important

Dans Visual Studio 2019, vous devez spécifier explicitement un mode IntelliSense Clang lorsque vous générez avec clang ou clang-cl.

Pour reproduire ces builds en dehors de Visual Studio, consultez Exécuter CMake à partir de la ligne de commande ou d’un pipeline CI.

Pour générer sur Linux ou sans l’ensemble d’outils Visual C++, spécifiez le nom d’un compilateur sur votre PATH instance ou une variable d’environnement qui prend la valeur du chemin complet d’un compilateur. Les chemins complets sont déconseillés afin que le fichier puisse rester partageable. Une présélection qui s’appuie sur GCC version 8 peut ressembler à ceci :

"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
  "CMAKE_C_COMPILER": "gcc-8",
  "CMAKE_CXX_COMPILER": "g++-8"
},

Vous pouvez également définir des compilateurs avec un fichier de chaîne d’outils CMake. Les fichiers de chaîne d’outils peuvent être définis avec cacheVariables.CMAKE_TOOLCHAIN_FILE, ce qui équivaut à passer -D CMAKE_TOOLCHAIN_FILE=<value> à CMake à partir de la ligne de commande. Un fichier de chaîne d’outils CMake est le plus souvent utilisé pour la compilation croisée. Pour plus d’informations sur la création de fichiers de chaîne d’outils CMake, consultez les chaînes d’outils CMake.

Sélectionner votre générateur

Les modèles prédéfinis windows et Linux spécifient Ninja comme générateur par défaut. D’autres générateurs courants sont les générateurs Visual Studio sur Windows et Unix Makefiles sur Linux et macOS. Vous pouvez spécifier un nouveau générateur avec l’option generator dans une présélection de configuration. Cela équivaut à passer -G à CMake à partir de la ligne de commande.

Définissez et toolset.strategy définissez set quand vous générez architecture.strategy un générateur Visual Studio. Pour plus d’informations, consultez les générateurs CMake.

Sélectionner votre type de configuration

Vous pouvez définir le type de configuration (Debug ou Release) pour les générateurs de configuration uniques à l’aide cacheVariables.CMAKE_BUILD_TYPEde . Cela équivaut à passer -D CMAKE_BUILD_TYPE=<value> à CMake à partir de la ligne de commande. Pour plus d’informations, consultez CMAKE_BUILD_TYPE.

Sélectionnez votre architecture cible et hôte lors de la génération avec l’ensemble d’outils Visual C++

Vous pouvez définir l’architecture cible (x64, Win32, ARM64 ou ARM) à l’aide architecture.valuede . Cela équivaut à passer -A à CMake à partir de la ligne de commande. Pour plus d’informations, consultez La sélection de la plateforme.

Remarque

Actuellement, Visual Studio Generators attend la syntaxe Win32 et les générateurs de ligne de commande (comme Ninja) attendent la syntaxe x86 lorsque vous créez pour x86.

Vous pouvez définir l’architecture hôte (x64 ou x86) et l’ensemble d’outils à l’aide toolset.valuede . Cela équivaut à passer -T à CMake à partir de la ligne de commande. Pour plus d’informations, consultez Sélection de l’ensemble d’outils.

Les architecture.strategy valeurs et toolset.strategy les valeurs indiquent à CMake comment gérer les champs d’architecture et d’ensemble d’outils. set signifie que CMake définit la valeur respective et external signifie que CMake ne définit pas la valeur respective.

Nous vous recommandons d’utiliser set des générateurs IDE comme Visual Studio Generator. Utilisez external avec des générateurs de ligne de commande comme Ninja. Ces valeurs permettent aux fournisseurs comme Visual Studio de fournir l’environnement requis avant l’appel de CMake. Pour plus d’informations sur les champs architecture et ensemble d’outils, consultez la liste des présélections de configuration.

Si vous ne souhaitez pas sourcer un environnement, vous pouvez définir architecture.strategy sur et architecture.value sur unspecifiedexternal . Vous pouvez trouver utile de ne pas sourcer un environnement pour l’une des raisons suivantes :

  • Vous utilisez un ensemble d’outils autre que MSVC.
  • Vous utilisez une chaîne d’outils personnalisée, comme dans les scénarios incorporés.
  • Vous n’avez pas besoin d’un environnement spécifique pour générer.

Pour obtenir la liste complète des générateurs d’IDE qui prennent en charge le champ d’architecture, consultez CMAKE_GENERATOR_PLATFORM. Pour obtenir la liste complète des générateurs d’IDE qui prennent en charge le champ ensemble d’outils, consultez CMAKE_GENERATOR_TOOLSET.

Utilisez les exemples suivants pour cibler ARM64 avec le générateur Ninja ou pour cibler Win32 (x86) avec le générateur Visual Studio 16 2019 :

"generator": "Ninja",
"architecture": {
    "strategy": "external",
    "value": "arm64"
},

"generator": "Visual Studio 16 2019",
"architecture": {
    "strategy": "set",
     "value": "Win32"
},

Définir et référencer des variables d’environnement

Vous pouvez définir des variables d’environnement à l’aide de la carte d’environnement. Les variables d’environnement sont héritées par le inherits champ, mais vous pouvez les remplacer comme vous le souhaitez.

L’environnement d’une présélection est l’union de son propre environnement et de l’environnement de tous ses parents. Si plusieurs inherits présélections fournissent des valeurs conflictuelles pour la même variable, la présélection précédente dans la inherits liste est recommandée. Vous pouvez annuler la définition d’une variable héritée d’une autre présélection en la définissant sur null.

Les variables d’environnement définies dans une présélection de configuration circulent également automatiquement vers les présélections de build et les présélections de test associées, sauf si inheritConfigureEnvironment elle est définie sur false. Pour plus d’informations, consultez la liste des présélections.

Vous pouvez référencer des variables d’environnement à l’aide de la syntaxe et $penv{<variable-name>} de la $env{<variable-name>} syntaxe. Pour plus d’informations, consultez Extension des macros.

Configurer IntelliSense pour un compilateur croisé

Par défaut, Visual Studio utilise le mode IntelliSense qui correspond à votre ensemble d’outils et à votre architecture cible spécifiées. Si vous compilez plusieurs fois, vous devrez peut-être spécifier manuellement le mode IntelliSense approprié à l’aide de l’option intelliSenseMode dans visual Studio Paramètres carte fournisseur. Pour plus d’informations, consultez l’entrée de intelliSenseMode la table sous Visual Studio Paramètres carte fournisseur.

Configurer et générer sur un système distant ou le Sous-système Windows pour Linux

Avec CMakePresets.json la prise en charge de Visual Studio, vous pouvez facilement configurer et générer votre projet sur des systèmes Windows, WSL et distants. Les étapes de configuration et de génération de votre projet sur Windows, un système distant ou WSL sont identiques. Toutefois, quelques comportements sont spécifiques au développement à distance.

${sourceDir} comportement dans les scénarios de copie à distance

Dans les scénarios locaux (y compris WSL1), ${sourceDir} évalue le chemin d’accès au répertoire source du projet ouvert dans Visual Studio. Dans les scénarios de copie à distance, ${sourceDir} évalue le chemin d’accès au répertoire source du projet sur le système cible et non le répertoire source du projet sur l’ordinateur local.

La valeur de sourceDir visual Studio Remote Paramètres fournisseur détermine le répertoire source du projet sur le système cible (valeur par défaut$env{HOME}/.vs/$ms{projectDirName}). Pour plus d’informations, consultez l’entrée de sourceDir la table sous Visual Studio Paramètres carte fournisseur.

Dossier local pour la sortie distante

Les scénarios de copie à distance nécessitent un répertoire local pour copier certains fichiers distants tels que les fichiers de réponse de l’API de fichier CMake ou les fichiers de build si copyBuildOutput dans la carte du fournisseur Paramètres à distance Visual Studio est définie truesur . Ces fichiers sont automatiquement copiés vers <local-source-directory>/out/<remote-connection-ID>/build/${presetName}.

Appel de la même présélection de configuration sur Windows et WSL1

Une erreur s’affiche si vous essayez d’utiliser la même présélection de configuration sur Windows et WSL1. Windows et WSL1 utilisent tous les deux le système de fichiers Windows. CMake essaie donc d’utiliser le même répertoire de sortie (binaryDir) pour les arborescences de build Windows et WSL1.

Si vous souhaitez utiliser la même présélection de configuration avec Windows et l’ensemble d’outils WSL1, créez une deuxième présélection configurer qui hérite de la présélection d’origine et spécifie une nouvelle binaryDir valeur. Dans l’exemple suivant, windows-preset vous pouvez l’utiliser sur Windows et base-preset l’utiliser sur WSL1 :

{
  "name": "windows-preset",
  "inherits": "base-preset",
  "binaryDir": "${sourceDir}/out/build/${presetName}",
  "vendor": {
    "microsoft.com/VisualStudioSettings/CMake/1.0": {
      "hostOS": "Windows"
    }
  }
}

Remarque

Dans Visual Studio 2019, seul l’ensemble d’outils WSL1 est pris en charge. Ce comportement s’affiche chaque fois que vous appelez configure sur Windows et WSL.

Activer l’intégration de vcpkg

Vcpkg vous aide à gérer des bibliothèques C et C++ sur Windows, Linux et macOS. Un fichier de chaîne d’outils vcpkg (vcpkg.cmake) doit être transmis à CMake pour activer l’intégration de vcpkg. Pour plus d’informations, consultez la documentation vcpkg.

Visual Studio ne transmet plus automatiquement votre fichier de chaîne d’outils vcpkg à CMake lorsque CMakePresets.json l’intégration est activée. Cette modification élimine le comportement spécifique à Visual Studio et garantit que vous pouvez reproduire votre build à partir de la ligne de commande.

Au lieu de cela, définissez le chemin d’accès à vcpkg.cmake l’aide de la variable d’environnement VCPKG_ROOT dans CMakePresets.json:

"cacheVariables": {
   "CMAKE_TOOLCHAIN_FILE": {
      "value": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
       "type": "FILEPATH"
    }
 },

VCPKG_ROOT doit être défini sur la racine de votre installation vcpkg. Pour plus d’informations, consultez les variables d’environnement vcpkg.

Si vous utilisez déjà un fichier de chaîne d’outils CMake et que vous souhaitez activer l’intégration de vcpkg, consultez Utilisation de plusieurs fichiers de chaîne d’outils. Suivez ces instructions pour utiliser un fichier de chaîne d’outils externe avec un projet à l’aide de vcpkg.

Substitution de variable dans launch.vs.json et tasks.vs.json

CMakePresets.json prend en charge la substitution des variables dans launch.vs.json et tasks.vs.json. Voici quelques éléments à prendre en compte :

  • Les variables d’environnement définies dans la présélection de configuration active transitent automatiquement vers launch.vs.json et tasks.vs.json configurations. Vous pouvez annuler l’affectation de variables d’environnement individuelles et launch.vs.jsontasks.vs.json les définir sur null. L’exemple suivant définit la variable DEBUG_LOGGING_LEVELnull dans launch.vs.json: "env": { "DEBUG_LOGGING_LEVEL": null }.

  • Les valeurs clés définies dans la présélection de configuration active sont disponibles pour la consommation launch.vs.json et tasks.vs.json avec la syntaxe ${cmake.<KEY-NAME>}. Par exemple, utilisez cette option ${cmake.binaryDir} pour référencer le répertoire de sortie de la présélection de configuration active.

  • Les variables d’environnement individuelles définies dans la carte d’environnement de la présélection de configuration active sont disponibles pour la consommation et launch.vs.jsontasks.vs.json via la syntaxe ${env.<VARIABLE-NAME>}.

Mettez à jour vos fichiers et task.vs.json vos launch.vs.json fichiers pour référencer CMakePresets.json la syntaxe au lieu de la CMakeSettings.json syntaxe. Les macros qui référencent l’ancienne CMakeSettings.json syntaxe lorsque CMakePresets.json le fichier de configuration actif est prévu pour dépréciation dans une version ultérieure. Par exemple, référencez le répertoire de sortie de la présélection de configuration active à ${cmake.binaryDir} la place de ${cmake.buildRoot}, car CMakePresets.json utilise la binaryDir syntaxe.

Résoudre les problèmes

Si les choses ne fonctionnent pas comme prévu, vous pouvez essayer quelques étapes de résolution des problèmes.

Si l’une ou l’autre CMakePresets.jsonCMakeUserPresets.json n’est pas valide, Visual Studio revient sur son comportement par défaut et affiche uniquement les présélections de configuration par défaut. Visual Studio IntelliSense peut vous aider à intercepter la plupart de ces erreurs JSON, mais elle ne sait pas si vous référencez une présélection avec inherits ou configurePreset par le nom incorrect.

Pour case activée si vos fichiers prédéfinis sont valides, exécutez cmake --list-presets à partir de la ligne de commande à la racine de votre répertoire de projet. (CMake 3.20 ou version ultérieure est requis.) Si l’un ou l’autre fichier n’est pas valide, l’erreur suivante s’affiche :

CMake Error: Could not read presets from
C:/Users/<user>/source/repos/<project-name>: JSON parse error

Voici d’autres étapes de résolution des problèmes :

  • Supprimez le cache et reconfigurez le projet (CMake : Supprimer le cache et project>Configurez <le nom> du projet).
  • Fermez et rouvrez le dossier dans Visual Studio (dossier de fermeture de fichier>).
  • Supprimez le .vs dossier à la racine de votre projet.

Si vous avez identifié un problème, la meilleure façon de le signaler consiste à sélectionner le bouton Envoyer des commentaires dans le coin supérieur droit de Visual Studio.

Activer la journalisation pour les connexions distantes

Vous pouvez activer la journalisation pour les connexions à distance si vous rencontrez des problèmes de connexion ou de copie de fichiers dans un système distant. Pour plus d’informations, consultez Journalisation des connexions à distance.

Activer AddressSanitizer pour Windows et Linux

Visual Studio prend en charge AddressSanitizer (ASAN), un détecteur d’erreurs de mémoire du runtime C et C++, à la fois pour le développement Windows et Linux. L’option addressSanitizerEnabled dans CMakeSettings.json active AddressSanitizer. CMakePresets.json ne prend pas en charge ce comportement.

Au lieu de cela, activez et désactivez AddressSanitizer en définissant vous-même les indicateurs du compilateur et de l’éditeur de liens requis. La définition de ces paramètres supprime le comportement spécifique à Visual Studio et garantit que le même CMakePresets.json fichier peut reproduire votre build à partir de la ligne de commande.

Vous pouvez ajouter l’exemple suivant pour CMakeLists.txt activer ou désactiver AddressSanitizer pour une cible :

option(ASAN_ENABLED "Build this target with AddressSanitizer" ON)

if(ASAN_ENABLED)
  if(MSVC)
    target_compile_options(<target> PUBLIC /fsanitize=address)
  else()
    target_compile_options(<target> PUBLIC -fsanitize=address <additional-options>)
    target_link_options(<target> PUBLIC -fsanitize=address)
  endif()
endif()

La <additional-options> partie répertorie d’autres indicateurs de compilation, comme "-fno-omit-frame-pointer". Pour plus d’informations sur AddressSanitizer pour Linux, consultez Utilisation de AddressSanitizer. Pour plus d’informations sur l’utilisation de AddressSanitizer avec MSVC, consultez Utiliser AddressSanitizer à partir d’une invite de commandes développeur.

Passez des indicateurs d’exécution à AddressSanitizer à l’aide du ASAN_OPTIONS champ dans launch.vs.json. ASAN_OPTIONS par detect_leaks=0 défaut lorsqu’aucune autre option d’exécution n’est spécifiée, car LeakSanitizer n’est pas pris en charge dans Visual Studio.

Exécuter CMake à partir de la ligne de commande ou d’un pipeline CI

Vous pouvez utiliser les mêmes fichiers et CMakeUserPresets.json les mêmes CMakePresets.json fichiers pour appeler CMake dans Visual Studio et à partir de la ligne de commande. La documentation CMake et CTest sont les meilleures ressources pour appeler CMake et CTest avec --preset. CMake version 3.20 ou ultérieure est requis.

Approvisionnement de l’environnement lors de la création avec des générateurs de ligne de commande sur Windows

Il incombe à l’utilisateur de configurer l’environnement avant que CMake soit appelé dans la génération avec un générateur de ligne de commande. Si vous créez avec Ninja et l’ensemble d’outils Visual C++ sur Windows, définissez l’environnement avant que CMake soit appelé pour générer le système de génération. Vous pouvez le faire en appelant vcvarsall.bat avec l’argument architecture . L’argument architecture spécifie l’architecture hôte et cible à utiliser. Pour plus d’informations, consultez vcvarsall la syntaxe. Si vous générez sur Linux ou sur Windows avec un générateur Visual Studio, vous n’avez pas besoin d’effectuer cette étape.

Il s’agit de la même étape que Visual Studio pour vous lorsque l’IDE appelle CMake. Visual Studio analyse la présélection de configuration active pour l’architecture hôte et cible spécifiée par toolset et architecture. Visual Studio source ensuite l’environnement spécifié à partir de vcvarsall.bat. Lorsque vous générez à partir de la ligne de commande Windows avec Ninja, vous devez effectuer cette étape vous-même.

vcvarsall.bat est installé avec Build Tools pour Visual Studio. Par défaut, vcvarsall.bat est installé dans C:\Program Files (x86)\Microsoft Visual Studio\2019\<edition>\VC\Auxiliary\Build. Vous pouvez l’ajouter vcvarsall.batPATH si vous utilisez souvent le flux de travail de ligne de commande.

Exemple de flux de travail de ligne de commande

Vous pouvez utiliser les commandes suivantes pour configurer et générer un projet CMake qui utilise Ninja pour cibler ARM64 avec des outils de génération x64. CMake version 3.20 ou ultérieure est requis. Exécutez ces commandes à partir du répertoire où se trouve votre CMakePresets.json fichier :

/path/to/vcvarsall.bat x64_arm64 
cmake --list-presets=all .
cmake --preset <configurePreset-name>
cmake --build --preset <buildPreset-name>

Exemple de fichier CMakePresets.json

Le CMakePresets.json fichier dans box2d-lite contient des exemples de présélections, de présélections de build et de présélections de test. Pour plus d’informations sur cet exemple, consultez la présentation Présentation de CMakePresets.json. Vous pouvez voir un autre exemple dans le projet DirectXTK , qui affiche de nombreuses cibles de génération dans sa configurePresets section.

Étapes suivantes

Consultez les rubriques suivantes pour en savoir plus sur la configuration et le débogage des projets CMake dans Visual Studio :

Projets CMake dans Visual Studio
Personnaliser les paramètres de génération CMake
Configurer des sessions de débogage CMake
Informations de référence sur la configuration prédéfinie de CMake