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

Cet article présente les fonctionnalités du débogueur Visual Studio dans une procédure pas à pas. 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 mettre en pause 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

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 d'applications de bureau avec C++ installée.

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

  • 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. Sélectionnez Outils>Obtenir des outils et des fonctionnalités.

    2. Dans Visual Studio Installer, sélectionnez l’onglet Charges de travail.

    3. Sélectionnez la charge de travail de développement de Bureau avec C++, puis sélectionnez Modifier.

    4. Suivez les instructions et terminez 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 Démarrer de Visual Studio (Fichier >Fenêtre de démarrage), sélectionnez Créer un nouveau projet :

   

2. Définissez le filtre langage sur C++ et définissez le filtre plateforme sur Windows .

3. Dans la zone de recherche, entrez 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 ? située après les résultats de recherche et sélectionnez Installer d’autres outils et fonctionnalités. Dans l'installer de Visual Studio, sélectionnez la charge de travail Développement d'applications bureau avec 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 Démarrer le débogage en tant que Nom de projet et Nom de 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 fichier get-started-debugging.cpp est ouvert dans l’éditeur de code.

Créer l’application

Créez une application pour votre projet en modifiant le fichier get-started-debugging.cpp 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 Déboguer > Démarrer le débogage. Vous pouvez également sélectionner Démarrer le débogage (icône de flèche verte pleine) 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) sur la barre d’outils de débogage. Vous pouvez également utiliser le raccourci clavier Maj + 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’exécution au point sélectionné dans le débogueur :

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

      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 qui contient l’instruction de code name += letters[i]; en cliquant dans la marge de 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ébogage>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

Une façon pratique de parcourir votre code dans le débogueur consiste à utiliser les commandes de pas . Ces commandes vous permettent de entrer dans, de passer par-dessus, de sortir d' d'une section de code, ainsi que de reculer 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, sélectionnez F11 (Déboguer > pas à pas dans) 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 Sortie. Sélectionnez Maj + F11 (Déboguer > Sortir).

   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, sélectionnez F10 (Déboguer > pas à pas).

   

   Notez cette fois 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 sélectionnez F10 sur l’appel de méthode SendMessage (au lieu de F11), vous pas à pas le code d’implémentation de SendMessage. Cette approche est utile pour passer outre le code que vous n'avez pas besoin d'inspecter actuellement. Pour plus d’informations sur les différentes façons de vous déplacer dans votre code, consultez Parcourir le code dans le débogueur.

Parcourir votre code avec Exécuter pour cliquer

Une autre façon de parcourir votre code dans le débogueur est d’utiliser la fonctionnalité Exécuter pour cliquer sur. 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.

   Pointez jusqu’à ce que l'Exécuter pour cliquer sur (icône de 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. Sélectionnez Exécuter jusqu'à cliquer sur.

   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 Exécuter pour cliquer sur 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 sélectionnez Redémarrer, le débogueur s'interrompt au premier point d'arrêt rencontré pendant l'exécution. 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é des 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. Sélectionnez F5 (Déboguer>Continuer) quelques fois pour itérer plusieurs fois à travers la boucle de 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 pour inspecter les variables et les valeurs consiste à utiliser les fenêtres Autos et Locals. 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. Remarquez la fenêtre Autos 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 plus d’informations, consultez les Visual Studio Language Guidance.

2. Examinez ensuite la fenêtre Locals. Par défaut, cette fenêtre est alignée en regard 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 Observateur pour spécifier une variable (ou une expression) à 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 aux autres fenêtres de variables, la fenêtre Surveillance affiche toujours les variables que vous regardez. Lorsqu’une variable surveillée n’est pas dans la portée, 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 de débogage dans certains IDE comme 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 en pause dans la boucle for, sélectionnez la fenêtre Pile d'appels pour voir la structure actuelle des appels.

   Si vous ne voyez pas la fenêtre pendant votre session de débogage, sélectionnez Débogage>Fenêtres>Pile des appels pour ouvrir la fenêtre.

2. Sélectionnez F11 (Déboguer>pas à pas dans) quelques 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 actuelle (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 n’avance pas le débogueur.

• Accédez aux menus contextuels pour les éléments de programmation dans la fenêtre de pile des appels . Par exemple, vous pouvez insérer des points d’arrêt dans des fonctions spécifiées, avancer le débogueur à l’aide de Exécuter jusqu'au curseuret 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é du débogueur dans Visual Studio est la possibilité de modifier le flux d’exécution de votre application :

1. Sélectionnez F11 (Déboguer>pas à pas dans) 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.

Contenu connexe

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