Tutoriel : Déboguer du code C++ avec Visual Studio

Dans ce tutoriel, vous déboguez une application C++ à l’aide du débogueur Visual Studio. Lorsque vous déboguez une application, vous exécutez généralement votre application avec le débogueur attaché. Le débogueur fournit de nombreuses façons d’examiner ce que fait votre code pendant l’exécution du programme. Vous pouvez parcourir votre code et examiner les valeurs stockées dans des variables et définir des montres sur des variables pour voir quand les valeurs changent. Le débogueur vous aide à examiner le chemin d’exécution de votre code et à confirmer qu’une branche de code est en cours d’exécution.

Dans ce tutoriel, vous allez :

• Démarrer le débogueur et l’interrompre aux points d’arrêt
• Découvrir les commandes pour parcourir le code dans le débogueur
• Inspecter des variables dans des bulles d’informations et dans les fenêtres du débogueur
• Examiner la pile des appels
• Définir des arguments de ligne de commande pour votre application

Si vous débutez avec le débogage, vous pouvez lire Débogage pour les débutants absolus avant de commencer ce didacticiel. Si vous souhaitez une vue de niveau supérieur des fonctionnalités du débogueur, consultez Premier aperçu du débogueur.

Conditions préalables

• Visual Studio 2022 version 17.12 ou ultérieure avec la charge de travail Développement Desktop en C++ installée.

  • Pour installer Visual Studio gratuitement, accédez à la page de téléchargements Visual Studio.

  • Si vous disposez déjà de Visual Studio, vous pouvez installer la charge de travail à partir de l’environnement de développement interactif (IDE) :

    1. Cliquez sur Outils>Obtenir des outils et des fonctionnalités.
    2. Dans Visual Studio Installer, sélectionnez l’onglet Charges de travail.
    3. Sélectionnez le module de travail Développement de bureau avec C++, puis sélectionnez Modifier.
    4. Suivez les instructions et complétez l'installation.

• Ce tutoriel utilise une application de démonstration C++ et les captures d’écran présentent la syntaxe C++. La plupart des fonctionnalités illustrées sont également applicables à C#, Visual Basic, F#, Python, JavaScript et d’autres langages pris en charge par Visual Studio. Il existe quelques limitations à garder à l’esprit :

  • F# : la fonctionnalité Modifier et continuer n’est pas prise en charge.
  • F# et JavaScript: la fenêtre Autos n’est pas prise en charge.

Créer un projet

Suivez ces étapes pour créer un projet d’application console C++ dans Visual Studio. Le type de projet fournit tous les fichiers de modèle dont vous avez besoin pour commencer rapidement :

1. Dans la fenêtre de démarrage Visual Studio (Fichier>Fenêtre de démarrage), sélectionnez Créer un nouveau projet:

   

2. Définissez le filtre Langue sur C++ et définissez le filtre Plateforme sur Windows.

3. Dans la zone Recherche, saisissez console, puis sélectionnez le modèle Application console dans la liste des résultats :

   

   Remarque

   Si vous ne voyez pas le modèle application console, vous pouvez l’installer à partir de la fenêtre Créer un projet. Localisez la section Vous ne trouvez pas ce que vous recherchez ? qui suit les résultats de recherche et sélectionnez Installer d'autres outils et fonctionnalités. Dans Visual Studio Installer, sélectionnez la charge de travail Développement Desktop en C++ et mettez à jour votre installation. Pour plus d’informations, consultez la section Prérequis.

4. Sélectionnez suivant pour passer à la page de configuration.

5. Entrez get-started-debugging le nom du projet et le nom de la solution pour votre nouvelle application. Choisissez l’emplacement par défaut ou accédez à un autre chemin d’accès dans votre environnement.

6. Sélectionnez Créer pour créer le projet Node.js.

Visual Studio crée votre projet et ouvre votre hiérarchie de projet dans l’Explorateur de solutions. Le get-started-debugging.cpp fichier est ouvert dans l’éditeur de code.

Créer l’application

Créez une application pour votre projet en modifiant le get-started-debugging.cpp fichier dans l’éditeur de code.

Remplacez le contenu par défaut fourni par le modèle par le code suivant :

#include <string>
#include <vector>
#include <iostream>

void SendMessage(const std::wstring& name, int msg)
{
   std::wcout << L"Hello, " << name << L"! Count to " << msg << std::endl;
}

int main()
{
   std::vector<wchar_t> letters = { L'f', L'r', L'e', L'd', L' ', L's', L'm', L'i', L't', L'h' };
   std::wstring name = L"";
   std::vector<int> a(10);
   std::wstring key = L"";

   for (int i = 0; i < letters.size(); i++)
   {
      name += letters[i];
      a[i] = i + 1;
      SendMessage(name, a[i]);
   }
   std::wcin >> key;
   return 0;
}

Démarrer le débogueur

Vous êtes maintenant prêt à commencer à déboguer votre code mis à jour :

1. Démarrez la session de débogage en sélectionnant F5 ou Debug > Démarrer le débogage. Vous pouvez également cliquer sur Démarrer le débogage (icône représentant une flèche verte unie) dans la barre d’outils Débogage.

   Le raccourci clavier F5 démarre l’application avec le débogueur attaché au processus d’application, mais vous n’avez rien de spécial à examiner dans le code. L’application charge simplement et vous voyez la sortie de la console :

   Hello, f! Count to 1
   Hello, fr! Count to 2
   Hello, fre! Count to 3
   Hello, fred! Count to 4
   Hello, fred ! Count to 5
   Hello, fred s! Count to 6
   Hello, fred sm! Count to 7
   Hello, fred smi! Count to 8
   Hello, fred smit! Count to 9
   Hello, fred smith! Count to 10
   

   Plus loin dans le tutoriel, vous examinez plus en détail cette application dans le débogueur et explorez d’autres fonctionnalités de débogage.

2. Arrêtez le débogueur en sélectionnant Arrêter (icône carrée rouge) dans la barre d’outils de débogage. Vous pouvez également utiliser le raccourci clavier Shift + F5.

3. Dans la fenêtre de console de l’application en cours d’exécution, sélectionnez n’importe quelle clé, puis sélectionnez Entrer pour fermer la fenêtre.

Définir un point d’arrêt et démarrer le débogueur

Essayez de définir un point d’arrêt et de mettre en pause à l'endroit sélectionné dans le débogueur :

1. Revenez au fichier dans l’éditeur get-started-debugging.cpp de code et recherchez la for boucle de la main fonction :

      for (int i = 0; i < letters.size(); i++)
      {
         name += letters[i];
         a[i] = i + 1;
         SendMessage(name, a[i]);
      }
   

2. Définissez un point d’arrêt sur la ligne comportant l’instruction de code name += letters[i]; en cliquant dans la marge gauche sur la ligne de l’instruction. Visual Studio ajoute un cercle rouge dans la marge pour indiquer le point d’arrêt défini.

   Conseil

   Vous pouvez également placer votre curseur sur une ligne de code et sélectionner F9 pour activer le point d’arrêt de cette ligne.

   Les points d’arrêt sont l’une des fonctionnalités les plus élémentaires et essentielles du débogage fiable. Un point d’arrêt indique où vous souhaitez que Visual Studio suspende votre code en cours d’exécution. Lorsque l’exécution est suspendue, vous pouvez examiner les valeurs des variables, examiner le comportement de la mémoire ou vérifier si une branche de code est exécutée.

3. Démarrez votre application dans le débogueur en sélectionnant F5 ou Démarrer le débogage.

   Visual Studio démarre l’exécution de votre application. Lorsque le débogueur atteint votre point d’arrêt défini, le processus de débogage s’interrompt.

   Visual Studio ajoute une flèche jaune au cercle de point d’arrêt rouge dans la marge pour représenter l’instruction de code où le débogueur est suspendu. L’exécution du programme est suspendue et l’instruction indiquée attend d’être traitée.

   

   Remarque

   L’action de F5 est relative à l’état d’exécution actuel de votre application. Si votre application n’est pas en cours d’exécution et que vous sélectionnez F5, le débogueur démarre votre application et continue l’exécution jusqu’à ce qu’elle atteigne le premier point d’arrêt défini. Ce comportement est mappé à la commande Débogage>Démarrer le débogage. Si votre application est déjà en cours d’exécution et que vous sélectionnez F5, l’exécution de l’application continue jusqu’à ce que le débogueur atteigne le point d’arrêt ou la fin du programme suivant. Ce comportement est mappé à la commande Déboguer>Continuer.

Les points d’arrêt sont une fonctionnalité utile lorsque vous connaissez la ligne de code ou la section de code que vous souhaitez examiner en détail. Pour plus d’informations sur les différents types de points d’arrêt que vous pouvez définir, tels que les points d’arrêt conditionnels, consultez Utiliser le type approprié de point d’arrêt.

Parcourir votre code dans le débogueur

Un moyen pratique de parcourir votre code dans le débogueur consiste à utiliser les commandes d’étape. Ces commandes vous permettent d’effectuer un Pas à pas détaillé, un Pas à pas principal, un Pas à pas sortant dans une section de code, ainsi que de passer à l’Étape précédente dans l’exécution de l’application.

La procédure suivante montre comment utiliser des raccourcis clavier avec des commandes d’étape pour parcourir rapidement votre code. (Les actions de menu équivalentes sont affichées entre parenthèses.)

1. Démarrez votre application dans le débogueur en sélectionnant F5 ou Démarrer le débogage.

2. Pendant que le débogueur est suspendu dans la boucle for dans la fonction main, appuyez sur F11 (Déboguer > Pas à pas détaillé) deux fois pour passer à l’appel de méthode SendMessage.

   Après avoir sélectionné F11 deux fois, l’exécution continue à l’instruction de code SendMessage(name, a[i]);.

3. Sélectionnez F11 à nouveau pour passer à pas dans la méthode SendMessage.

   Notez que le pointeur jaune avance dans la méthode SendMessage :

   

   Le raccourci clavier F11 lance la commande Pas à pas dans, qui avance l’exécution d’une instruction d’application à la fois. Il est judicieux d’examiner le flux d’exécution en détail. Par défaut, le débogueur ignore le code non-utilisateur. Pour plus d'informations, consultez Just My Code. Plus loin dans le tutoriel, vous allez apprendre à parcourir plus rapidement votre code.

4. Après avoir examiné la méthode SendMessage, vous pouvez continuer le débogage avec la commande Pas à pas sortant. Appuyez sur Maj + F11 (Déboguer > Pas à pas sortant).

   Cette commande reprend l’exécution de l’application (et avance le débogueur) jusqu’à ce que la méthode ou la fonction actuelle retourne.

   Une fois la commande terminée, le débogueur s’interrompt dans la boucle for de la méthode main à l’appel de méthode SendMessage.

5. Sélectionnez F11 plusieurs fois jusqu’à ce que vous reveniez à nouveau à l’appel de méthode SendMessage.

6. Pendant que le débogueur est suspendu à l’appel de méthode, appuyez sur F10 (Déboguer > Pas à pas principal).

   

   Notez cette fois-ci que le débogueur n’effectue pas de pas à pas détaillé dans la méthode SendMessage. Le raccourci F10 avance le débogueur sans passer aux fonctions ou méthodes de votre code d’application (le code s’exécute toujours). Lorsque vous appuyez sur F10 sur l’appel de méthode SendMessage (au lieu de F11), vous effectuez un Pas à pas principal dans le code d’implémentation de SendMessage. Cette approche est utile pour ignorer le code que vous n’avez pas besoin d’inspecter pour le moment. Pour plus d’informations sur les différentes façons de parcourir votre code, consultez Naviguer dans le code avec le débogueur.

Parcourir votre code avec Exécuter jusqu’au clic

Un autre moyen de parcourir votre code dans le débogueur consiste à utiliser la fonctionnalité Exécuter jusqu’au clic. Cette action est similaire à la définition d’un point d’arrêt temporaire.

Poursuivez avec votre session de débogage :

1. Sélectionnez F5 pour passer au point d’arrêt de votre code.

2. Dans l’éditeur de code, faites défiler jusqu’à la définition de méthode SendMessage, puis pointez sur la fonction std::wcout.

   Survolez jusqu’à ce que la fonctionnalité Exécuter jusqu’au clic (icône représentant une flèche verte) s’affiche à gauche de l’instruction de code. Si vous pointez sur l’icône, vous voyez l’info-bulle « Exécuter l’exécution ici » :

   

3. Cliquez sur Exécuter jusqu’au clic.

   Le débogueur avance l’exécution à la position indiquée. Dans cet exemple, le débogueur parvient à l’appel à la fonction std::wcout.

L’action Run to Click est pratique pour vous déplacer rapidement dans une région visible du code de l’application. Vous pouvez utiliser la fonctionnalité dans n’importe quel fichier ouvert dans l’éditeur de code.

Redémarrer rapidement votre application

Redémarrez rapidement votre application en sélectionnant Redémarrer (icône de flèche circulaire) dans la barre d’outils Debug. Vous pouvez également sélectionner Déboguer > Redémarrer ou utiliser le raccourci clavier Ctrl + Maj + F5.

La fonctionnalité Redémarrer est plus efficace que d’arrêter l’application et de redémarrer le débogueur.

Lorsque vous cliquez sur Redémarrer, le débogueur s’interrompt au premier point d’arrêt qu’il rencontre lorsqu’il s’exécute. Dans cet exemple, le débogueur s’arrête à nouveau au point d’arrêt que vous définissez à l’intérieur de la boucle for.

Inspecter des variables avec des bulles d’informations (datatips)

Les fonctionnalités qui vous aident à inspecter les variables constituent l’un des avantages les plus utiles de l’utilisation du débogueur. Souvent, lorsque vous déboguez un problème, vous essayez de déterminer si les variables stockent des valeurs attendues à des moments particuliers. Visual Studio fournit plusieurs façons de vous aider à effectuer cette tâche.

Poursuivez avec votre session de débogage :

1. Pendant que le débogueur est suspendu sur l’instruction name += letters[i], pointez sur la variable letters. Sélectionnez la flèche développer/réduire à gauche du nom de la variable et affichez ses propriétés dans le menu volant.

   La fonctionnalité d’astuces de données affiche tous les éléments que la variable contient. Notez la valeur par défaut, size={10}:

   

2. Ensuite, pointez sur la variable name et notez sa valeur actuelle, une chaîne vide ("").

3. Appuyez sur F5 (Déboguer>Continuer) quelques fois pour itérer plusieurs fois à travers la boucle for. Chaque fois que le débogueur s’interrompt au point d’arrêt, pointez sur la variable name et vérifiez la valeur actuelle :

   

   La valeur de la variable change avec chaque itération de la boucle for, affichant les valeurs de f, puis fr, puis fre, et ainsi de suite.

Inspecter des variables avec les fenêtres Autos et Locals

Une autre approche de l’inspection des variables et des valeurs consiste à utiliser les fenêtres Variables automatiques et Variables locales. Par défaut, ces fenêtres apparaissent sous l’éditeur de code dans l’IDE Visual Studio pendant que vous déboguez votre application :

1. Notez la fenêtre Variables automatiques sous l’éditeur de code.

   Si vous ne voyez pas la fenêtre pendant votre session de débogage, sélectionnez Déboguer>Windows>Autos pour ouvrir la fenêtre.

   La fenêtre Autos affiche toutes les variables utilisées sur la ligne actuelle ou la ligne précédente, ainsi que leur valeur actuelle. N’oubliez pas que des langages de programmation spécifiques peuvent présenter un comportement unique pour les variables et les propriétés. Pour en savoir plus, consultez Conseils sur le langage Visual Studio.

2. Examinez ensuite la fenêtre Variables locales. Par défaut, cette fenêtre est alignée à côté de la fenêtre Autos.

   Si vous ne voyez pas la fenêtre pendant votre session de débogage, sélectionnez Déboguer>Windows>Locals pour ouvrir la fenêtre

3. Dans la fenêtre Locals, développez la variable letters pour afficher les éléments qu’il contient.

   

   La fenêtre Locals affiche les variables qui se trouvent dans l’étendue actuelle, autrement dit le contexte d’exécution actuel.

Regarder une variable

Si vous souhaitez observer le comportement d’une variable spécifique, vous pouvez définir un point d'observation:

Dans l’éditeur de code, cliquez avec le bouton droit sur la variable name, puis sélectionnez Ajouter une montre. La fenêtre Watch s’ouvre sous l’éditeur de code. Vous pouvez utiliser une fenêtre d'Observation pour spécifier une variable (ou une expression) que vous souhaitez suivre.

Lorsque vous regardez la variable name pendant l’exécution de l’application dans le débogueur, vous pouvez voir sa valeur changer. Contrairement à d’autres fenêtres de variables, la fenêtre Espion présente toujours les variables que vous observez. Lorsqu’une variable surveillée n’est pas dans le champ, le nom de la variable est grisé.

Examiner la pile des appels

La fenêtre pile des appels dans Visual Studio affiche l’ordre dans lequel les méthodes et les fonctions sont appelées. Cette fenêtre est similaire à la perspective Débogage dans certains IDE tels qu’Eclipse. Par défaut, la pile des appels est visible dans le volet inférieur droit pendant la session de débogage sous l’éditeur de code.

1. Pendant que le débogueur est suspendu dans la boucle for, sélectionnez la fenêtre Pile des appels pour afficher la structure actuelle des appels.

   Si vous ne voyez pas la fenêtre pendant votre session de débogage, sélectionnez Debug>Windows>Call Stack pour ouvrir la fenêtre.

2. Appuyez sur F11 (Déboguer>Pas à pas détaillé) plusieurs fois, jusqu’à ce que le débogueur s’interrompe dans la méthode SendMessage.

3. Examinez à nouveau la fenêtre Pile des appels :

   

   Dans la fenêtre Pile des appels, la ligne supérieure affiche la fonction active (la méthode SendMessage dans cette application). La deuxième ligne montre que la méthode SendMessage a été appelée à partir de la méthode main, et ainsi de suite.

La pile des appels est un bon moyen d’examiner et de comprendre le flux d’exécution d’une application :

• Double-cliquez sur une ligne de code pour accéder au code source. Cette action modifie également l’étendue actuelle sous inspection par le débogueur, mais elle ne fait pas avancer le débogueur.
• Accédez aux menus contextuels pour les éléments de programmation dans la fenêtre Pile des appels. Par exemple, vous pouvez insérer des points d’arrêt dans des fonctions spécifiées, faire avancer le débogueur à l’aide d’Exécuter jusqu’au curseur, puis accéder au code source. Pour plus d’informations, consultez Afficher la pile des appels et utiliser la fenêtre Pile des appels dans le débogueur.

Modifier le flux d’exécution

Une autre fonctionnalité de débogueur puissante est la possibilité de modifier le flux d’exécution pendant le débogage :

1. Appuyez sur F11 (Déboguer>Pas à pas détaillé) deux fois pour exécuter la fonction std::wcout.

2. Pendant que le débogueur est suspendu dans l’appel de méthode SendMessage, sélectionnez et faites glisser la flèche jaune (pointeur d’exécution) à gauche de la variable et déplacez la flèche vers l’instruction de code précédente, std::wcout.

3. Sélectionnez F11 à nouveau.

   Le débogueur réexécute la fonction std::wcout. Vous pouvez suivre le processus dans la sortie du terminal.

   En modifiant le flux d’exécution, vous pouvez effectuer des opérations telles que tester différents chemins d’exécution de code ou réexécuter du code sans redémarrer le débogueur.

   Attention

   Faites attention lors de l’utilisation de cette fonctionnalité. Lorsque vous sélectionnez la flèche jaune, Visual Studio affiche un avertissement dans l’info-bulle indiquant que la modification d’exécution peut avoir des conséquences inattendues. Vous pouvez également voir d’autres avertissements, en fonction de votre scénario. N’oubliez pas que le déplacement du pointeur ne peut pas rétablir votre application à un état d’application antérieur.

4. Sélectionnez F5 pour terminer l’exécution de l’application.

Passer des arguments de ligne de commande

Définissez des arguments de ligne de commande pour votre application dans les propriétés du projet. Cela est utile lorsque vous souhaitez tester le comportement de votre application avec différents arguments de ligne de commande.

À compter de Visual Studio 2026, vous pouvez définir des arguments de ligne de commande pour votre application dans la liste déroulante des arguments de ligne de commande. Cette fonctionnalité est disponible pour les projets Visual Studio C++, les projets Unreal Engine .uproject et les projets CMake. Il est actuellement en préversion et est susceptible de changer avant la version finale.

Modifiez l’application pour accepter les arguments de ligne de commande en remplaçant le code dans le get-started-debugging.cpp fichier par les éléments suivants :

#include <string>
#include <vector>
#include <iostream>
#include <algorithm>

void SendMessage(const std::wstring& name, int msg)
{
    std::wcout << L"Hello, " << name << L"! Count to " << msg << std::endl;
}

int main(int argc, char* argv[])
{
    // Detect if the /u command-line argument was passed to the application.
    bool uppercase = false;
    for (int i = 1; i < argc; ++i)
    {
        if (std::string(argv[i]) == "/u")
        {
            uppercase = true;
            break;
        }
    }

    std::vector<wchar_t> letters = { L'f', L'r', L'e', L'd', L' ', L's', L'm', L'i', L't', L'h' };
    std::wstring name = L"";
    std::vector<int> a(10);
    std::wstring key = L"";

    for (int i = 0; i < letters.size(); i++)
    {
        name += letters[i];
        a[i] = i + 1;
        std::wstring nameToSend = name;

        if (uppercase) // Convert the name to uppercase if the /u argument was passed.
        {
            std::transform(nameToSend.begin(), nameToSend.end(), nameToSend.begin(), ::towupper);
        }
        SendMessage(nameToSend, a[i]);
    }
    return 0;
}

Cette version mise à jour de l’application accepte un argument /u de ligne de commande qui convertit le nom en majuscules avant de le sortir.

Pour passer l’argument /u de ligne de commande à l’application lorsque vous commencez à le déboguer, procédez comme suit :

1. Dans la barre d’outils Standard , zone de texte arguments de ligne de commande , tapez /u:

   

2. Placez un point d’arrêt sur la ligne 19, uppercase = true;en cliquant sur la coupe gauche sur cette ligne.

   

3. Démarrez le débogage de votre application en sélectionnant le bouton Démarrer le débogage ou en appuyant sur F5.

4. Le débogueur atteint le point d’arrêt, car /u il a été passé en tant qu’argument de ligne de commande :

   

5. Sélectionnez F5 pour continuer à exécuter l’application. La sortie de la fenêtre de console affiche les noms en majuscules maintenant :

Hello, F! Count to 1
Hello, FR! Count to 2
Hello, FRE! Count to 3
Hello, FRED! Count to 4
Hello, FRED ! Count to 5
Hello, FRED S! Count to 6
Hello, FRED SM! Count to 7
Hello, FRED SMI! Count to 8
Hello, FRED SMIT! Count to 9
Hello, FRED SMITH! Count to 10

Les arguments de ligne de commande sont enregistrés dans la liste déroulante dans l’ordre dans lequel vous les entrez et apparaissent dans la liste déroulante pour une utilisation ultérieure. Il existe une limite de cinq lignes de commande que vous pouvez ajouter avant que la plus ancienne soit supprimée pour en faire place pour la nouvelle.

Vous pouvez sélectionner la flèche de liste déroulante pour afficher la liste des arguments de ligne de commande précédemment utilisés.

Passer des arguments de ligne de commande dans différents types de projet

La liste déroulante arguments de ligne de commande contient une option spécifique de type de projet pour ouvrir la façon classique de définir les arguments que le débogueur passe à votre programme. Pour .vcxproj les projets, il s’agit de la page de propriétés des paramètres du projet. Pour les projets CMake, il s’agit de modifier le vs.launch.json fichier. Pour les projets Unreal Engine, il s’agit de modifier le .uproject fichier.

Type de projet Visual Studio (.vcxproj)

Dans un projet Visual Studio (.vcxproj), une option apparaît dans la liste déroulante arguments de ligne de commande pour modifier dans les pages de propriétés :

Sélectionnez Modifier dans les pages de propriétés pour ouvrir la fenêtre des propriétés du projet dans la page de propriétés débogage où vous définissez les arguments de ligne de commande à passer lors du débogage de votre application :

Les modifications apportées aux arguments de commande sont reflétées dans la liste déroulante arguments de ligne de commande pour les futures sessions de débogage.

Type de projet CMake

Pour les projets CMake, une option apparaît dans la liste déroulante arguments de ligne de commande dans laquelle modifier launch.vs.json:

Sélectionnez Modifier dans launch.vs.json, pour ouvrir le launch.vs.json fichier et définir les arguments de ligne de commande à passer lors du débogage de votre application dans l’élément "args" :

Les modifications apportées au fichier sont reflétées dans la liste déroulante arguments de ligne de commande pour les futures sessions de débogage.

Type de projet Unreal Engine (.uproject)

Pour les projets Unreal Engine, une option apparaît dans la liste déroulante arguments de ligne de commande dans laquelle modifier UETargetProperties.json:

Sélectionnez Modifier dans UETargetProperties.json, pour ouvrir le UETargetProperties.json fichier dans lequel vous définissez les arguments de ligne de commande à passer lors du débogage de votre application dans l’élément « args » :

Les modifications apportées au fichier sont reflétées dans la liste déroulante arguments de ligne de commande pour les futures sessions de débogage.

Contenu connexe

• Premier aperçu du débogueur Visual Studio
• Parcourir le code à l’aide du débogueur Visual Studio
• Utiliser le type d’arrêt approprié (.NET, .NET Framework, C++, Tous les langages)