Partager via

Prise en charge de la fonctionnalité Dossier ouvert pour les systèmes de génération C++ dans Visual Studio

La fonctionnalité Ouvrir un dossier est disponible dans Visual Studio 2017 et versions ultérieures.

Dans Visual Studio 2017 et ultérieur, la fonctionnalité « Ouvrir un dossier » vous permet d’ouvrir un dossier de fichiers sources et de commencer immédiatement à coder en bénéficiant des avantages suivants : IntelliSense, navigation, refactorisation, débogage, etc. Au fil des modifications, créations, déplacements et suppressions de fichiers, Visual Studio effectue automatiquement le suivi des modifications et met à jour en permanence son index IntelliSense. Aucun fichier .sln ou .vcxproj n’est chargé. Si nécessaire, vous pouvez spécifier des tâches personnalisées ou générer et lancer des paramètres par le biais de fichiers .json simples. Cette fonctionnalité vous permet d’intégrer n’importe quel système de génération tiers dans Visual Studio. Pour des informations générales sur la fonctionnalité Dossier ouvert, consultez Développer du code dans Visual Studio sans projets ni solutions.

CMake et Qt

CMake est intégré à l’environnement IDE de Visual Studio en tant que composant de la charge de travail de bureau C++. Le workflow pour CMake n’est pas identique au workflow décrit dans cet article. Si vous utilisez CMake, consultez Projets CMake dans Visual Studio. Vous pouvez également utiliser CMake pour générer des projets Qt, ou utiliser l’extension Qt Visual Studio pour Visual Studio 2015 ou Visual Studio 2017.

Autres systèmes de génération

Pour utiliser l’environnement IDE de Visual Studio avec un système de génération ou un ensemble d’outils du compilateur qui n’est pas directement pris en charge à partir du menu principal, sélectionnez Fichier | Ouvrir | Dossier ou appuyez sur Ctrl + Maj + Alt + O. Accédez au dossier qui contient vos fichiers de code source. Pour générer le projet, configurer IntelliSense et définir des paramètres de débogage, vous ajoutez trois fichiers JSON :

Fichier Descriptif
CppProperties.json Spécifiez les informations de configuration personnalisées pour la navigation. Si nécessaire, créez ce fichier dans votre dossier de projet racine. (Non utilisé dans les projets CMake.)
tasks.vs.json Spécifiez des commandes de génération personnalisées. Accessible via l’option Configurer les tâches du menu contextuel de l’Explorateur de solutions.
launch.vs.json Spécifiez des arguments de ligne de commande pour le débogueur. Accessible via l’option Paramètres de débogage et de lancement du menu contextuel de l’Explorateur de solutions.

Configurer la navigation dans le code avec CppProperties.json

Afin qu’IntelliSense et le comportement de navigation tel que Atteindre la définition fonctionnent correctement, Visual Studio doit savoir quel compilateur vous utilisez, où se trouvent les en-têtes système et où se trouvent des fichiers include supplémentaires s’ils ne se trouvent pas directement dans le dossier que vous avez ouvert (le dossier de l’espace de travail). Pour spécifier une configuration, vous pouvez choisir Gérer les configurations dans la liste déroulante de la barre d’outils principale :

Liste déroulante de configuration dans la barre d’outils montrant la sélection Gérer les configurations.

Visual Studio offre les configurations par défaut suivantes :

Boîte de dialogue Ajouter une configuration à CppProperties, affichant la liste des configurations par défaut : x86-Debug, x86-Release, x64-Debug, x64-Release, et ainsi de suite.

Si, par exemple, vous choisissez x64-Debug, Visual Studio crée un fichier appelé CppProperties.json dans votre dossier de projet racine :

{
  "configurations": [
    {
      "inheritEnvironments": [
        "msvc_x64"
      ],
      "name": "x64-Debug",
      "includePath": [
        "${env.INCLUDE}",
        "${workspaceRoot}\\**"
      ],
      "defines": [
        "WIN32",
        "_DEBUG",
        "UNICODE",
        "_UNICODE"
      ],
      "intelliSenseMode": "windows-msvc-x64"
    }
  ]
}

Cette configuration hérite des variables d’environnement de l’invite de commandes développeur x64 de Visual Studio. L’une de ces variables est INCLUDE et vous pouvez vous y référer ici à l’aide de la macro ${env.INCLUDE}. La propriété includePath indique à Visual Studio où rechercher toutes les sources dont elle a besoin pour IntelliSense. Dans ce cas, un message du type « examinez tous les répertoires spécifiés par la variable d’environnement INCLUDE, ainsi que tous les répertoires de l’arborescence des dossiers de travail actuels » s’affiche. La propriété name est le nom qui s’affiche dans la liste déroulante ; vous pouvez lui donner n’importe quel nom. La propriété defines fournit des conseils à IntelliSense lorsqu’elle rencontre des blocs de compilation conditionnels. La propriété intelliSenseMode fournit des indicateurs supplémentaires en fonction du type de compilateur. Plusieurs options sont disponibles pour MSVC, GCC et Clang.

Note

Si Visual Studio semble ignorer les paramètres dans CppProperties.json, essayez d’ajouter une exception dans le fichier .gitignore comme suit : !/CppProperties.json.

Configuration par défaut pour MinGW-w64

Si vous ajoutez la configuration MinGW-W64, le code JSON se présente comme suit :

{
  "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.BIN_ROOT};${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"
        }
      ]
    }
  ]
}

Notez le bloc environments. Il définit des propriétés qui se comportent comme des variables d’environnement et qui sont disponibles non seulement dans le fichier CppProperties.json, mais également dans les autres fichiers de configuration task.vs.json et launch.vs.json. La configuration Mingw64 hérite de l’environnement mingw_w64 et utilise sa propriété INCLUDE pour spécifier la valeur de includePath. Vous pouvez ajouter d’autres chemins à cette propriété de tableau en fonction des besoins.

La propriété intelliSenseMode est définie sur une valeur appropriée pour GCC. Pour plus d’informations sur toutes ces propriétés, consultez Informations de référence sur le schéma CppProperties.

Lorsque tout fonctionne correctement, IntelliSense s’affiche à partir des en-têtes GCC lorsque vous placez votre curseur sur un type :

Capture d’écran d’une fenêtre contextuelle GCC IntelliSense montrant la documentation d’en-tête.

Activer les diagnostics IntelliSense

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

Boîte de dialogue Options, affichant les paramètres de journalisation des diagnostics.

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 qu’IntelliSense essaie d’utiliser. Si les chemins d’accès ne correspondent pas à ceux de CppProperties.json, essayez de fermer le dossier et de supprimer le sous-dossier .vs qui contient des données de navigation mises en cache.

Définir des tâches de génération avec tasks.vs.json

Vous pouvez automatiser les scripts de génération ou d’autres opérations externes sur les fichiers de votre espace de travail actuel en les exécutant comme des tâches directement dans l’IDE. Vous pouvez configurer une nouvelle tâche en cliquant sur un fichier ou dossier puis en sélectionnant Configurer les tâches.

Menu contextuel de l’Explorateur de solutions affichant la commande Configurer les tâches.

Cette opération crée (ou ouvre) le fichier tasks.vs.json dans le dossier .vs créé par Visual Studio dans votre dossier de projet racine. Vous pouvez définir une tâche arbitraire dans ce fichier, puis l’appeler à partir du menu contextuel de l’Explorateur de solutions. Pour continuer l’exemple GCC, l’extrait de code suivant montre un fichier tasks.vs.json complet avec une tâche unique qui appelle g++.exe pour générer un projet. Supposons que le projet contient un fichier unique appelé hello.cpp.

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskLabel": "build hello",
      "appliesTo": "/",
      "type": "default",
      "command": "g++",
      "args": [
        "-g",
        "-o",
        "hello",
        "hello.cpp"
      ]
    }
  ]
}

Le fichier JSON est placé dans le sous-dossier .vs. Pour afficher ce dossier, cliquez sur le bouton Afficher tous les fichiers en haut de l’Explorateur de solutions. Vous pouvez exécuter cette tâche en cliquant avec le bouton droit sur le nœud racine dans l’Explorateur de solutions et en choisissant build hello. Une fois la tâche terminée, vous devriez voir un nouveau fichier, hello.exe dans l’Explorateur de solutions.

Vous pouvez définir de nombreux types de tâches. L’exemple suivant montre un fichier tasks.vs.json qui définit une tâche unique. taskLabel définit le nom qui s’affiche dans le menu contextuel. appliesTo définit les fichiers sur lesquels la commande peut être exécutée. La propriété command fait référence à la variable d’environnement COMSPEC qui identifie le chemin de la console (cmd.exe sur Windows). Vous pouvez également référencer des variables d’environnement déclarées dans CppProperties.json ou CMakeSettings.json. La propriété args spécifie la ligne de commande à appeler. La macro ${file} extrait le fichier sélectionné dans l’Explorateur de solutions. L’exemple suivant affiche le nom du fichier .cpp actuellement sélectionné.

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskLabel": "Echo filename",
      "appliesTo": "*.cpp",
      "type": "command",
      "command": "${env.COMSPEC}",
      "args": ["echo ${file}"]
    }
  ]
}

Après avoir enregistré tasks.vs.json, vous pouvez cliquer avec le bouton droit sur n’importe quel fichier .cpp contenu dans le dossier et choisir Echo filename à partir du menu contextuel. Le nom du fichier s’affiche dans la fenêtre Sortie.

Pour plus d’informations, consultez Informations de référence sur le schéma Tasks.vs.json.

Configurer les paramètres de débogage avec launch.vs.json

Pour personnaliser les arguments de ligne de commande et les instructions de débogage de votre programme, cliquez avec le bouton droit sur l’exécutable dans l’Explorateur de solutions et sélectionnez Paramètres de débogage et de lancement. Cette action ouvre un fichier launch.vs.json existant, ou s’il n’en existe aucun, crée un fichier avec un ensemble de paramètres de lancement minimal. Tout d’abord, vous pouvez choisir le type de session de débogage que vous souhaitez configurer. Pour déboguer un projet MinGw-w64, nous choisissons C/C++ Launch for MinGW/Cygwin (gdb). Une configuration de lancement pour l’utilisation de gdb.exe est créée avec des suppositions plausibles sur les valeurs par défaut. L’une de ces valeurs par défaut est MINGW_PREFIX. Vous pouvez remplacer le chemin littéral (comme indiqué ci-dessous) ou définir une propriété MINGW_PREFIX dans CppProperties.json :

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "cppdbg",
      "name": "hello.exe",
      "project": "hello.exe",
      "cwd": "${workspaceRoot}",
      "program": "${debugInfo.target}",
      "MIMode": "gdb",
      "miDebuggerPath": "c:\\msys64\\usr\\bin\\gdb.exe",
      "externalConsole": true
    }
  ]
}

Pour démarrer le débogage, choisissez l’exécutable dans la liste déroulante de débogage, puis cliquez sur la flèche verte :

Liste déroulante cible de débogage de la barre d’outils, affichant la flèche verte pour démarrer le débogueur.

Vous devriez voir la boîte de dialogue Initialisation du débogueur , puis une fenêtre de console externe qui exécute votre programme.

Pour plus d’informations, consultez Référence du schéma Launch.vs.json (C++).

Lancement d’autres exécutables

Vous pouvez définir des paramètres de lancement pour n’importe quel exécutable sur votre ordinateur. L’exemple suivant lance 7za et spécifie des arguments supplémentaires, en les ajoutant au tableau JSON args :

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "default",
      "project": "CPP\\7zip\\Bundles\\Alone\\O\\7za.exe",
      "name": "7za.exe list content of helloworld.zip",
      "args": [ "l", "d:\\sources\\helloworld.zip" ]
    }
  ]
}

Quand vous enregistrez ce fichier, la nouvelle configuration apparaît dans le menu déroulant Cible de débogage. Vous pouvez la sélectionner pour démarrer le débogueur. Vous pouvez créer autant de configurations Debug que vous le souhaitez, pour n’importe quel nombre d’exécutables. Si vous appuyez sur F5 maintenant, le débogueur démarre et atteint tout point d’arrêt déjà défini. Toutes les fenêtres et fonctionnalités du débogueur que vous connaissez bien sont désormais disponibles.

  • Last updated on