`CppProperties.json` référence

Les projets de type dossier qui n'utilisent pas CMake peuvent stocker les paramètres de configuration du projet pour IntelliSense dans un fichier CppProperties.json. (Les projets CMake utilisent un fichier CMakeSettings.json.) Une configuration se compose de paires nom/valeur et définit les chemins d'inclusion #include, les options du compilateur et d'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	Descriptif
`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 (correspondant à `/I` pour la plupart des compilateurs)
`defines`	Liste des macros qui devraient être définies (correspond à `/D` pour 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 (correspond à `/FI` pour MSVC ou `-include` pour clang)
`undefines`	La liste des macros à ne pas définir (mappées à `/U` pour 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	Descriptif
`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	Descriptif
`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 syntaxe ${env.VARIABLE} à partir de tasks.vs.json et launch.vs.json après leur définition ici. 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	Descriptif
`${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 également *windows.h * ainsi que d'autres en-têtes courants du Kit de développement logiciel (SDK) Windows, vous pouvez mettre à jour votre fichier de configuration CppProperties.json 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 vers l'invite de commandes pour développeurs.)

Corriger les erreurs IntelliSense

Si vous ne voyez pas l'IntelliSense que vous attendez, vous pouvez résoudre les problèmes en accédant à Outils>Options>Editeur de texte>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 de sortie et est visible lorsque vous choisissez Afficher la sortie de : Journal Visual C++. La sortie contient, entre autres, la liste des chemins d’inclusion réels qu'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 include manquants, ouvrez l'onglet Liste des erreurs, puis filtrez sa sortie sur « IntelliSense uniquement » et le code d’erreur E1696 « ne peut pas ouvrir le fichier source ... ».

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-02-24