Partager via

CppProperties.json référence

  • Article

Ouvrez les projets dossier qui n’utilisent pas CMake peuvent stocker les paramètres de configuration de projet pour IntelliSense dans un CppProperties.json fichier. (Les projets CMake utilisent un CMakeSettings.json fichier.) Une configuration se compose de paires nom/valeur et définit #include chemins d’accès, commutateurs du compilateur et autres paramètres. Pour plus d’informations sur l’ajout de configurations dans un projet Open Folder, consultez Open Folder projects for C++. Les sections suivantes résument les différents paramètres. Pour obtenir une description complète du schéma, accédez à CppProperties_schema.json, dont le chemin d’accès complet est donné en haut de l’éditeur de code lorsqu’il CppProperties.json est ouvert.

Propriétés de configuration

Une configuration peut avoir l’une des propriétés suivantes :

Nom Description
inheritEnvironments Spécifie les environnements qui s’appliquent à cette configuration.
name Nom de configuration qui s’affiche dans la liste déroulante de configuration C++
includePath Liste séparée par des virgules de dossiers qui doivent être spécifiés dans le chemin d’accès include (mappe à /I la plupart des compilateurs)
defines Liste des macros à définir (mappée à /D la plupart des compilateurs)
compilerSwitches Un ou plusieurs commutateurs supplémentaires pouvant influencer le comportement d’IntelliSense
forcedInclude En-tête à inclure automatiquement dans chaque unité de compilation (mappée à /FI MSVC ou -include pour clang)
undefines Liste des macros à non définies (mappées à /U MSVC)
intelliSenseMode Moteur IntelliSense à utiliser Vous pouvez spécifier l’une des variantes spécifiques à l’architecture prédéfinies pour MSVC, gcc ou Clang.
environments Les ensembles de variables définis par l’utilisateur qui se comportent comme des variables d’environnement dans une invite de commandes sont accessibles avec la ${env.VARIABLE} macro.

Valeurs intelliSenseMode

L’éditeur de code affiche les options disponibles lorsque vous commencez à taper :

Capture d’écran de la fenêtre contextuelle IntelliSense dans l’éditeur.

Cette liste affiche les valeurs prises en charge :

  • windows-msvc-x86
  • windows-msvc-x64
  • windows-msvc-arm
  • windows-msvc-arm64
  • android-clang-x86
  • android-clang-x64
  • android-clang-arm
  • android-clang-arm64
  • ios-clang-x86
  • ios-clang-x64
  • ios-clang-arm
  • ios-clang-arm64
  • windows-clang-x86
  • windows-clang-x64
  • windows-clang-arm
  • windows-clang-arm64
  • linux-gcc-x86
  • linux-gcc-x64
  • linux-gcc-arm

Remarque : Les valeurs msvc-x86 et msvc-x64 sont prises en charge uniquement pour des raisons héritées. Utilisez plutôt les windows-msvc-* variantes.

Environnements prédéfinis

Visual Studio fournit les environnements prédéfinis suivants pour Microsoft C++ qui correspondent à l’invite de commandes développeur correspondante. Lorsque vous héritez de l’un de ces environnements, vous pouvez faire référence à l’une des variables d’environnement à l’aide de la propriété env globale avec cette syntaxe de macro : ${env.VARIABLE}.

Nom de la variable Description
vsdev Environnement Visual Studio par défaut
msvc_x86 Compiler pour x86 à l’aide d’outils x86
msvc_x64 Compiler pour AMD64 à l’aide d’outils 64 bits
msvc_arm Compiler pour ARM à l’aide d’outils x86
msvc_arm64 Compiler pour ARM64 à l’aide d’outils x86
msvc_x86_x64 Compiler pour AMD64 à l’aide d’outils x86
msvc_arm_x64 Compiler pour ARM à l’aide d’outils 64 bits
msvc_arm64_x64 Compiler pour ARM64 à l’aide d’outils 64 bits

Quand la charge de travail Linux est installée, les environnements suivants sont disponibles pour cibler à distance Linux et WSL :

Nom de la variable Description
linux_x86 Cibler Linux x86 à distance
linux_x64 Cibler Linux x64 à distance
linux_arm Cibler Linux ARM à distance

Environnements définis par l’utilisateur

Vous pouvez éventuellement utiliser la environments propriété pour définir des ensembles de variables dans le CppProperties.json monde entier ou par configuration. Ces variables se comportent comme des variables d’environnement dans le contexte d’un projet Open Folder. Vous pouvez y accéder avec la ${env.VARIABLE} syntaxe tasks.vs.json et launch.vs.json après leur définition. Toutefois, elles ne sont pas nécessairement définies en tant que variables d’environnement réelles dans une invite de commandes que Visual Studio utilise en interne.

Visual Studio 2019 version 16.4 et ultérieure : les variables spécifiques à la configuration définies dans CppProperties.json sont automatiquement récupérées par les cibles et tâches de débogage sans avoir à définir inheritEnvironments. Les cibles de débogage sont lancées automatiquement avec l’environnement que vous spécifiez dans CppProperties.json.

Visual Studio 2019 version 16.3 et antérieure : lorsque vous utilisez un environnement, vous devez le spécifier dans la inheritsEnvironments propriété même si l’environnement est défini dans le cadre de la même configuration ; la environment propriété spécifie le nom de l’environnement. L’exemple suivant montre un exemple de configuration permettant d’activer IntelliSense pour GCC dans une installation MSYS2. Notez comment la configuration définit et hérite de l’environnement mingw_64 et comment la includePath propriété peut accéder à la INCLUDE variable.

"configurations": [
    {

      "inheritEnvironments": [
        "mingw_64"
      ],
      "name": "Mingw64",
      "includePath ,": [
        "${env.INCLUDE}",
        "${workspaceRoot}\\**",
      ],
      "intelliSenseMode": "linux-gcc-x64",
      "environments": [
        {
          "MINGW64_ROOT": "C:\\msys64\\mingw64",
          "BIN_ROOT": "${env.MINGW64_ROOT}\\bin",
          "FLAVOR": "x86_64-w64-mingw32",
          "TOOLSET_VERSION": "9.1.0",
          "PATH": "${env.MINGW64_ROOT}\\bin;${env.MINGW64_ROOT}\\..\\usr\\local\\bin;${env.MINGW64_ROOT}\\..\\usr\\bin;${env.MINGW64_ROOT}\\..\\bin;${env.PATH}",
          "INCLUDE": "${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION};${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION}\\tr1;${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION}\\${env.FLAVOR};",
          "environment": "mingw_64"
        }
      ]
    }
  ]

Lorsque vous définissez une propriété à l’intérieur d’une "environments" configuration, elle remplace toutes les variables globales qui ont les mêmes noms.

Macros intégrées

Vous avez accès aux macros intégrées suivantes à l’intérieur de CppProperties.json :

Macro Description
${workspaceRoot} Chemin d’accès complet au dossier de l’espace de travail
${projectRoot} Chemin d’accès complet au dossier où CppProperties.json est placé
${env.vsInstallDir} Chemin d’accès complet au dossier dans lequel l’instance en cours d’exécution de Visual Studio est installée

Exemple

Si votre projet comporte un dossier Include et inclut *windows.hégalement * et d’autres en-têtes courants du Kit de développement logiciel (SDK) Windows, vous pouvez mettre à jour votre CppProperties.json fichier de configuration avec les éléments suivants :

{
  "configurations": [
    {
      "name": "Windows",
      "includePath": [
        // local include folder
        "${workspaceRoot}\\include",
        // Windows SDK and CRT headers
        "${env.WindowsSdkDir}\\include\\${env.WindowsSDKVersion}\\ucrt",
        "${env.NETFXSDKDir}\\include\\um",
        "${env.WindowsSdkDir}\\include\\${env.WindowsSDKVersion}\\um",
        "${env.WindowsSdkDir}\\include\\${env.WindowsSDKVersion}\\shared",
        "${env.VCToolsInstallDir}\\include"
      ]
    }
  ]
}

Remarque

%WindowsSdkDir% et %VCToolsInstallDir% ne sont pas définis en tant que variables d’environnement globales. Veillez à commencer devenv.exe à partir d’une invite de commandes développeur qui définit ces variables. (Tapez « développeur » dans le menu Démarrer de Windows pour rechercher un raccourci d’invite de commandes développeur.)

Corriger les erreurs IntelliSense

Si vous ne voyez pas IntelliSense que vous attendez, vous pouvez résoudre les problèmes en accédant à l’Éditeur>de texte Options>outils>C/C++>Avancé et en définissant Activer la journalisation . true Pour commencer, essayez de définir le niveau de journalisation sur 5 et les filtres de journalisation sur 8.

Capture d’écran des paramètres de journalisation des diagnostics dans la boîte de dialogue Options.

La sortie est redirigée vers la fenêtre Sortie et est visible lorsque vous choisissez Afficher la sortie à partir de : Journal Visual C++. La sortie contient, entre autres, la liste des chemins d’accès d’insertion réels que IntelliSense essaie d’utiliser. Si les chemins d’accès ne correspondent pas à ceux du CppProperties.jsondossier, essayez de fermer le dossier et de supprimer le .vs sous-dossier qui contient des données de navigation mises en cache.

Pour résoudre les erreurs IntelliSense provoquées par des chemins d’accès manquants, ouvrez l’onglet Liste d’erreurs, puis filtrez sa sortie sur « IntelliSense uniquement » et le code d’erreur E1696 « ne peut pas code source ouvert fichier ... ».