Partager via

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

  • Article

La fonctionnalité Ouvrir le 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 build 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’IDE Visual Studio en tant que composant de la charge de travail de bureau C++. Le flux de travail pour CMake n’est pas identique au flux de travail décrit dans cet article. Si vous utilisez CMake, consultez les 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’IDE Visual Studio avec un ensemble d’outils de build ou de 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, configurez IntelliSense et définissez des paramètres de débogage, vous ajoutez trois fichiers JSON :

Fichier Description
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 build 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

Pour que IntelliSense et le comportement de navigation tels que Go to Definition 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 Visual Studio x64. L’une de ces variables est INCLUDE et vous pouvez vous y référer ici à l’aide de la ${env.INCLUDE} macro. La includePath propriété indique à Visual Studio où rechercher toutes les sources dont elle a besoin pour IntelliSense. Dans ce cas, il indique « 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 ». La name propriété est le nom qui apparaîtra dans la liste déroulante et peut être tout ce que vous aimez. La defines propriété fournit des conseils à IntelliSense lorsqu’elle rencontre des blocs de compilation conditionnels. La intelliSenseMode propriété fournit des indicateurs supplémentaires en fonction du type de compilateur. Plusieurs options sont disponibles pour MSVC, GCC et Clang.

Remarque

Si Visual Studio semble ignorer les paramètres dans CppProperties.json, essayez d’ajouter une exception à votre 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 environments bloc. 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 Mingw64 configuration hérite de l’environnement mingw_w64 et utilise sa INCLUDE propriété pour spécifier la valeur pour includePath. Vous pouvez ajouter d’autres chemins d’accès à cette propriété de tableau si nécessaire.

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

Lorsque tout fonctionne correctement, IntelliSense s’affiche à partir des en-têtes GCC lorsque vous pointez 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 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 truesur . Pour commencer, essayez de définir le niveau de journalisation sur 5 et les filtres de journalisation sur 8.

Boîte de dialogue Options montrant 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 que 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.

Explorateur de solutions menu contextuel montrant la commande Configurer les tâches.

Cela crée (ou ouvre) le fichier tasks.vs.json dans le dossier .vs que Visual Studio crée 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 comme 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 Explorateur de solutions. Vous pouvez exécuter cette tâche en cliquant avec le bouton droit sur le nœud racine dans Explorateur de solutions et en choisissant build hello. Une fois la tâche terminée, vous devriez voir un nouveau fichier, hello.exe dans 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 apparaît dans le menu contextuel. appliesTo définit les fichiers sur lesquels la commande peut être exécutée. La command propriété fait référence à la variable d’environnement COMSPEC, qui identifie le chemin d’accès 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 dans le dossier, choisir un nom de fichier Echo dans le menu contextuel et afficher le nom de fichier affiché 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 Explorateur de solutions, puis sélectionnez Déboguer et lancer les paramètres. Cela ouvre un fichier launch.vs.json existant, ou s’il n’en existe aucun, il crée un fichier avec un ensemble de paramètres de lancement minimal. Tout d’abord, vous avez le choix entre 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). Cela crée une configuration de lancement pour l’utilisation de gdb.exe avec des estimations instruites 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 MINGW_PREFIX propriété 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 devez 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 launch.vs.json référence de schéma.

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 args tableau JSON :

{
  "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.