Créer une calculatrice console en C++

Le point de départ habituel pour un programmeur C++ est une application « Hello, world ! » qui s’exécute sur la ligne de commande. Vous commencez par cela dans cet article, puis passez à quelque chose de plus difficile : une application de calculatrice.

Conditions préalables

• Visual Studio avec la charge de travail développement de bureau avec C++ installée et en cours d'exécution sur votre ordinateur. Pour l’installer, consultez Installer la prise en charge de C++ dans Visual Studio.
• Ce tutoriel illustre une fonctionnalité appelée modification et poursuite qui vous permet d’apporter des modifications à votre code pendant l’exécution de l’application. Pour activer la modification et continuer, dans le menu principal, sélectionnez Outils>Options>Débogage>Général et assurez-vous que Exiger que les fichiers source correspondent exactement à la version originale est cochée.

Créer votre projet d’application

Visual Studio utilise des projets pour organiser le code d’une application et des solutions pour organiser un ou plusieurs projets. Un projet contient toutes les options, configurations et règles utilisées pour générer une application. Il gère également la relation entre tous les fichiers du projet et tous les fichiers externes. Pour créer votre application, commencez par créer un projet et une solution.

1. La boîte de dialogue Démarrer de Visual Studio s’affiche. Sélectionnez Créer un projet pour commencer.

   

   La boîte de dialogue dispose des options permettant de cloner un référentiel, d’ouvrir un projet ou une solution, d’ouvrir un dossier local et de créer un projet.

2. Dans la fenêtre Créer un projet, définissez la liste déroulante de langue sur C++, définissez la liste déroulante de plateforme sur Windows, sélectionnez Application console dans la liste des types de projets, puis sélectionnez Suivant.

   

   La liste déroulante de langue est définie sur C++, la liste déroulante de la plateforme est définie sur Windows et les types de projet tels que Projet vide, Application console, Projet CMake, Assistant Bureau Windows, etc., apparaissent dans la liste des types de projets.

   Important

   Veillez à sélectionner la version C++ du modèle d’application console . Il a les balises C++, Windows et Console , et l’icône a « ++ » dans le coin.

3. Dans la boîte de dialogue Configurer votre nouveau projet , sélectionnez la zone de texte Nom du projet, nommez votre nouveau projet CalculatorTutorial, puis sélectionnez Créer.

   

   Une application console Windows C++ vide « Hello World » est créée. Les applications console utilisent une fenêtre de console Windows pour afficher la sortie et accepter l’entrée utilisateur. Dans Visual Studio, une fenêtre d’éditeur s’ouvre et affiche le code généré :

   // CalculatorTutorial.cpp : This file contains the 'main' function. Program execution begins and ends there.
   //
   
   #include <iostream>
   
   int main()
   {
       std::cout << "Hello World!\n";
   }
   
   // Run program: Ctrl + F5 or Debug > Start Without Debugging menu
   // Debug program: F5 or Debug > Start Debugging menu
   
   // Tips for Getting Started:
   //   1. Use the Solution Explorer window to add/manage files
   //   2. Use the Team Explorer window to connect to source control
   //   3. Use the Output window to see build output and other messages
   //   4. Use the Error List window to view errors
   //   5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
   //   6. In the future, to open this project again, go to File > Open > Project and select the .sln file
   

Vérifier que votre nouvelle application génère et s’exécute

Le modèle d’une nouvelle application console Windows crée une application « Hello World » C++ simple. À ce stade, vous pouvez voir comment Visual Studio génère et exécute les applications que vous créez directement à partir de l’IDE.

1. Pour générer votre projet, sélectionnez Générer une solution dans le menu Générer . La fenêtre Sortie affiche les résultats du processus de génération.

   

2. Pour exécuter le code, dans le menu, sélectionnez Déboguer>Démarrer sans débogage (Ctrl+F5).

   

   Une fenêtre de console s’ouvre et votre application s’exécute dans celle-ci.

   Lorsque vous démarrez une application console dans Visual Studio, elle exécute votre code, puis imprime « Appuyez sur n’importe quelle touche pour fermer cette fenêtre . . » pour vous donner une chance de voir la sortie.

   Félicitations! Vous avez créé votre première application console « Hello, world ! » dans Visual Studio !

3. Appuyez sur une touche pour ignorer la fenêtre de console et revenir à Visual Studio.

Vous disposez maintenant des outils permettant de générer et d’exécuter votre application après chaque modification, pour vérifier que le code fonctionne toujours comme prévu. Plus tard, nous vous montrons comment le déboguer si ce n’est pas le cas.

Modifier le code

Nous allons maintenant modifier le code de ce modèle pour qu’il s’agit d’une application de calculatrice.

1. Remplacez le contenu du CalculatorTutorial.cpp fichier par le code suivant afin qu’il corresponde à cet exemple :

   // CalculatorTutorial.cpp : This file contains the 'main' function. Program execution begins and ends there.
   //
   
   #include <iostream>
   
   using namespace std;
   
   int main()
   {
       cout << "Calculator Console Application" << endl << endl;
       cout << "Please enter the operation to perform. Format: a+b | a-b | a*b | a/b"
           << endl;
       return 0;
   }
   
   // Run program: Ctrl + F5 or Debug > Start Without Debugging menu
   // Debug program: F5 or Debug > Start Debugging menu
   // Tips for Getting Started:
   //   1. Use the Solution Explorer window to add/manage files
   //   2. Use the Team Explorer window to connect to source control
   //   3. Use the Output window to see build output and other messages
   //   4. Use the Error List window to view errors
   //   5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
   //   6. In the future, to open this project again, go to File > Open > Project and select the .sln file
   

   Présentation du code :

   • L’instruction apporte du #include code dans d’autres fichiers. Parfois, vous pouvez voir un nom de fichier entouré de crochets angle comme <iostream>. Les crochets angle indiquent au compilateur de rechercher d’abord le iostream fichier d’en-tête dans les répertoires système standard, et s’ils ne sont pas trouvés, d’examiner les répertoires spécifiques au projet. D’autres fois, vous pouvez voir un nom de fichier entouré de guillemets comme "someHeader.h". Les guillemets indiquent au compilateur d’ignorer la recherche dans les répertoires système standard et de regarder uniquement dans les répertoires spécifiques au projet.
   • Le using namespace std; signale au compilateur d'attendre l'utilisation du code de la bibliothèque standard C++ dans ce fichier. Sans cette ligne, chaque mot clé de la bibliothèque devrait être précédé de std:: pour indiquer son étendue. Par exemple, sans cette ligne, chaque référence serait cout écrite en tant que std::cout. L’instruction using est ajoutée pour faciliter l’accès au code dans un autre espace de noms.
   • Le cout mot clé est utilisé pour imprimer la sortie standard en C++. L’opérateur << indique au compilateur d’envoyer ce qui est à droite de celui-ci à la sortie standard.
   • Le endl mot clé est semblable à la touche Entrée ; il termine la ligne et déplace le curseur vers la ligne suivante. Il est préférable de placer une \n à l'intérieur de la chaîne (contenue par "") pour faire la même chose, car endl vide toujours la mémoire tampon et peut nuire aux performances du programme. Mais comme il s’agit d’une très petite application, endl elle est utilisée à la place.
   • Toutes les instructions C++ doivent se terminer par des points-virgules et toutes les applications C++ doivent contenir une main() fonction. C'est la fonction que le programme exécute au démarrage. Tout le code doit être accessible depuis main() pour être utilisé.

2. Pour enregistrer le fichier, appuyez sur Ctrl+S ou sélectionnez l’icône de disque de floppy dans la barre d’outils sous la barre de menus.

3. Pour exécuter l’application, appuyez sur Ctrl+F5 ou accédez au menu Débogage , puis sélectionnez Démarrer sans débogage. Une fenêtre de console doit apparaître qui ressemble à ceci.

4. Fermez la fenêtre de console lorsque vous avez terminé.

Ajouter du code pour effectuer des calculs

Une classe est similaire à un blueprint pour un objet qui fait quelque chose. Dans ce cas, nous définissons une classe de calculatrice pour contenir la logique mathématique.

Ajouter une classe Calculatrice

1. Accédez au menu Projet et sélectionnez Ajouter une classe. Dans la zone de modification nom de la classe , entrez Calculatrice. Cliquez sur OK.

   

   Le champ nom de classe contient la calculatrice de texte. Le champ de fichier .h contient Calculator.h. Le champ de fichier .cpp contient Calculator.cpp. Le champ de classe de base est vide. Les options inline et Managed sont désactivées.

   Deux nouveaux fichiers sont ajoutés à votre projet. Pour enregistrer tous vos fichiers modifiés à la fois, appuyez sur Ctrl+Maj+S. Il s’agit d’un raccourci clavier pour File>Save All. Il existe également un bouton de barre d’outils pour Enregistrer tout, une icône de deux disques de floppy, située à côté du bouton Enregistrer . En règle générale, il est recommandé d’effectuer Sauvegarder tout fréquemment, afin de ne perdre aucune modification.

   L’Assistant Ajouter une classe crée des fichiers .h et .cpp portant le même nom que la classe. Vous pouvez voir une liste complète de vos fichiers projet dans la fenêtre Explorateur de solutions, visible sur le côté de l’IDE. Si la fenêtre n’est pas visible, ouvrez-la à partir de la barre de menus vial’Explorateur de solutions>.

   

   Le projet de didacticiel de calculatrice comporte un nœud de fichiers d’en-tête contenant Calculator.h. Un nœud Fichiers sources contient Calculator.cpp et CalculatorTutorial.cpp. Les nœuds pour les références, les dépendances externes et les fichiers de ressources sont visibles mais fermés.

   Vous pouvez ouvrir un fichier en double-cliquant dessus dans la fenêtre Explorateur de solutions . Double-cliquez Calculator.h pour l’ouvrir.

2. Remplacez le contenu du Calculator.h code suivant pour que le fichier ressemble maintenant à ceci :

   #pragma once
   class Calculator
   {
   public:
       double Calculate(double x, char oper, double y);
   };
   

   Présentation du code

   • Ce code déclare une nouvelle fonction appelée Calculate, qui gère les opérations mathématiques pour l’ajout, la soustraction, la multiplication et la division.
   • Le code C++ est organisé en fichiers d’en-tête (.h) et en fichiers sources (.cpp). Certaines autres extensions de fichier sont prises en charge par différents compilateurs, mais il s’agit des principales extensions à connaître. Les fonctions et les variables sont normalement déclarées, c’est-à-dire un nom et un type, dans les fichiers d’en-tête et implémentées, ou en fonction d’une définition, dans les fichiers sources. Pour accéder au code défini dans un autre fichier, vous pouvez utiliser #include "filename.h", où filename.h est le nom du fichier qui déclare les variables ou fonctions que vous souhaitez utiliser.
   • Il est recommandé d’organiser votre code en différents fichiers en fonction de ce qu’il fait. Il est donc facile de trouver le code dont vous avez besoin ultérieurement. Dans notre cas, nous définissons la Calculator classe séparément du fichier contenant la main() fonction, mais nous prévoyons de référencer la Calculator classe dans main().

3. Une bascule verte apparaît sous Calculate car bien que la Calculate fonction soit déclarée, elle n’est pas définie. Pointez sur Calculate, cliquez sur la flèche vers le bas sur l’icône de tournevis, puis sélectionnez Créer la définition de « Calculer » dans Calculator.cpp.

   

   Ce code est ajouté à Calculator.cpp:

   

   La définition de la fonction est : double Calculator ::Calculate( double x, char oper, double y) { return 0.0 ; }

   Actuellement, il retourne simplement 0.0. Nous allons changer leur mise en forme.

4. Basculez vers le Calculator.cpp fichier dans la fenêtre de l’éditeur. Remplacez le contenu de Calculator::Calculate(double x, char oper, double y) par :

   double Calculator::Calculate(double x, char oper, double y)
   {
       switch(oper)
       {
           case '+':
               return x + y;
           case '-':
               return x - y;
           case '*':
               return x * y;
           case '/':
               return x / y;
           default:
               return 0.0;
       }
   }
   

   Présentation du code

   • La fonction Calculate prend un nombre, un opérateur et un deuxième nombre. Ensuite, il effectue l’opération demandée sur les deux nombres.
   • L’instruction switch vérifie quel opérateur a été fourni et exécute le cas correspondant à cette opération. Le default: cas est un secours dans le cas où l’utilisateur tape un opérateur qui n’est pas géré par l’une des instructions précédentes case . Il est préférable de gérer les entrées utilisateur non valides de manière plus élégante, mais cela dépasse le cadre de ce didacticiel.
   • Le double mot clé désigne un type de nombre qui prend en charge les décimales. Ce type de nombre est appelé nombre à virgule flottante et double signifie un nombre à virgule flottante qui a une précision supplémentaire. De cette façon, la calculatrice peut gérer les mathématiques décimales et les mathématiques entières. La Calculate fonction est nécessaire pour toujours retourner un nombre à virgule flottante double précision en raison du double début du code (ce qui indique le type de retour de la fonction), c’est pourquoi nous renvoyons 0,0 dans le cas par défaut.
   • Le .h fichier déclare le prototype de fonction, qui indique au compilateur les paramètres requis et le type de retour attendu. Le .cpp fichier contient tous les détails de l’implémentation de la fonction.

Si vous générez et réexécutez le code à ce stade, il se ferme immédiatement après avoir demandé quelle opération effectuer. Modifiez donc la main fonction pour effectuer plusieurs calculs.

Appeler les fonctions membres de classe Calculator

1. Mettez à jour la fonction dans main comme suit :

   // CalculatorTutorial.cpp : This file contains the 'main' function. Program execution begins and ends there.
   //
   
   #include <iostream>
   #include "Calculator.h"
   
   using namespace std;
   
   int main()
   {
       double x = 0.0;
       double y = 0.0;
       double result = 0.0;
       char oper = '+';
   
       cout << "Calculator Console Application" << endl << endl;
       cout << "Please enter the operation to perform. Format: a+b | a-b | a*b | a/b"
            << endl;
   
       Calculator c;
       while (true)
       {
           cin >> x >> oper >> y;
           result = c.Calculate(x, oper, y);
           cout << "Result " << "of " << x << oper << y << " is: " << result << endl;
       }
   
       return 0;
   }
   

   Présentation du code

   • Étant donné que les programmes C++ commencent toujours à la main() fonction, nous devons appeler notre autre code à partir de là, afin qu’une #include instruction soit nécessaire pour rendre ce code visible par notre main() fonction.
   • Les variablesx, , yoper, et result sont déclarées pour stocker le premier nombre, le deuxième nombre, l’opérateur et le résultat final, respectivement. Il est toujours recommandé de leur donner des valeurs initiales pour éviter un comportement non défini, ce qui est ce qui est fait ici.
   • La Calculator c; ligne déclare un objet nommé c en tant qu’instance de la Calculator classe. La classe elle-même est simplement un blueprint pour la façon dont les calculatrices fonctionnent ; l’objet est la calculatrice spécifique qui effectue les mathématiques.
   • L’instruction while (true) est une boucle. Le code à l’intérieur de la boucle s’exécute à nouveau tant que la condition à l’intérieur de la () boucle a la valeur true. Étant donné que la condition est simplement répertoriée comme true, il est toujours vrai, donc la boucle s’exécute toujours. Pour fermer le programme, l’utilisateur doit fermer manuellement la fenêtre de console. Sinon, le programme attend toujours de nouvelles données.
   • Le cin mot clé accepte l’entrée de l’utilisateur. Le flux d’entrée est suffisamment intelligent pour traiter une ligne de texte entrée dans la fenêtre de console et le placer à l’intérieur de chacune des variables répertoriées, dans l’ordre.
   • L’expression c.Calculate(x, oper, y); appelle la fonction Calculate définie précédemment et fournit les valeurs d’entrée saisies et l’opération demandée. La fonction retourne ensuite un nombre stocké dans result.
   • Enfin, result est imprimé sur la console et l’utilisateur voit le résultat du calcul.

Générer et tester à nouveau le code

Testez à nouveau le programme pour vous assurer que tout fonctionne correctement.

1. Appuyez sur Ctrl+F5 pour reconstruire et démarrer l’application.

2. Entrez, puis 5+5 sur Entrée. Vérifiez que le résultat est 10.

   

   L’application génère le message : Entrez l’opération à effectuer. Format : a+b | a-b | a*b | a/b. L’utilisateur a entré 5+5. Sortie de l’application : Résultat de 5+5 : 10

3. Arrêtez le programme en fermant la fenêtre de console.

Déboguer l’application

Étant donné que l’utilisateur est libre de taper quoi que ce soit dans la fenêtre de console, nous allons vérifier que la calculatrice gère les entrées inattendues. Au lieu d’exécuter le programme, nous allons le déboguer afin de pouvoir inspecter ce qu’il fait pas à pas.

Exécuter l’application dans le débogueur

1. Dans CalcuatorTutorial.cpp, définissez un point d’arrêt sur la ligne : result = c.Calculate(x, oper, y);. Pour définir le point d’arrêt, cliquez en regard de la ligne dans la barre verticale grise le long du bord gauche de la fenêtre de l’éditeur afin qu’un point rouge s’affiche.

   

   Maintenant, lorsque nous débogueons le programme, l’exécution s’interrompt à cette ligne. Nous avons déjà une idée approximative que le programme fonctionne pour des cas simples. Étant donné que nous ne voulons pas suspendre l’exécution chaque fois que nous appelons Calculate(), nous allons rendre le point d’arrêt conditionnel.

2. Cliquez avec le bouton droit sur le point rouge qui représente le point d’arrêt, puis sélectionnez Conditions. Dans la zone d’édition de la condition, saisissez le texte (y == 0) && (oper == '/'). Sélectionnez le bouton Fermer pour enregistrer la condition de point d’arrêt.

   

   Le point d’arrêt se trouve sur la ligne : result = c dot Calculate ( x, oper, y). 'Conditions...' L’option Condition est cochée. La liste déroulante Conditions est définie sur « Expression conditionnelle ». La liste déroulante des conditions est définie sur « Est vrai ». La condition est définie sur y == 0 && oper == '/'.

   À présent, l’exécution s’interrompt au point d’arrêt lorsque l’application tente de diviser par 0.

3. Pour déboguer le programme, appuyez sur F5 ou sélectionnez le bouton de barre d’outils du débogueur Windows local qui a l’icône de flèche verte. Dans votre application console, si vous entrez quelque chose comme « 5 - 0 », le programme se comporte normalement et continue à s’exécuter. Toutefois, si vous tapez « 10 / 0 », il s’interrompt au point d’arrêt. Vous pouvez placer n’importe quel nombre d’espaces entre l’opérateur et les nombres : cin est suffisamment intelligent pour analyser l’entrée de manière appropriée.

   

Fenêtres utiles dans le débogueur

Lorsque vous déboguez votre code, vous remarquerez peut-être que certaines nouvelles fenêtres apparaissent. Ces fenêtres peuvent améliorer votre expérience de débogage. Jetez un coup d’œil à la fenêtre Autos . La fenêtre Autos affiche les valeurs actuelles des variables utilisées au moins trois lignes avant et jusqu’à la ligne actuelle. Si vous ne voyez pas la fenêtre Autos, dans le menu principal, sélectionnez Déboguer>, Windows>, et Autos.

La valeur de "oper" est 47, le caractère '/' est utilisé, le résultat est 5, x est 10 et y est 0.

Pour afficher toutes les variables de cette fonction, basculez vers la fenêtre Locals . Comme il s’agit d’une petite fonction, la fenêtre Autos et Locals affiche les mêmes variables. Toutefois, vous pouvez modifier les valeurs de ces variables dans la fenêtre Locals lors du débogage pour voir quel effet ils auraient sur le programme. Dans ce cas, nous les laissons seuls. Ouvrez la fenêtre Locals en sélectionnant Locals en bas de la fenêtre Autos ou en sélectionnant dans le menu principal Déboguer>Windows>Locals.

La valeur de oper est 47 '/', le résultat est 0, x est 10 et y est 0.

Vous pouvez également pointer sur des variables dans le code pour voir leurs valeurs actuelles au moment où l’exécution est actuellement suspendue. Vérifiez que la fenêtre de l’éditeur est en focus en cliquant sur celle-ci en premier.

Continuer le débogage

1. La flèche jaune à gauche indique le point d’exécution actuel. La ligne actuelle appelle Calculate, donc appuyez sur F11 pour entrer dans la fonction. Vous exécutez maintenant du code dans le corps de la Calculate fonction. Soyez prudent avec Pas à pas , car il effectue des étapes dans toutes les fonctions sur la ligne sur laquelle vous vous trouvez, y compris les fonctions de bibliothèque standard. Il est très intéressant de passer à la bibliothèque standard, mais vous serez peut-être plus intéressé à vous concentrer sur votre code plutôt que sur le code de la bibliothèque.

2. Maintenant que le point d’exécution est au début de la Calculate fonction, appuyez sur F10 pour passer à la ligne suivante dans l’exécution du programme. F10 est également appelé Step Over. Vous pouvez utiliser Step Over pour passer d’une ligne à l’autre, sans vous rendre compte des détails de ce qui se produit dans chaque partie de la ligne. En général, vous devez utiliser Exécution pas à pas au lieu de Points d'entrée, sauf si vous souhaitez explorer plus en profondeur le code appelé d’ailleurs (comme lorsque vous l'avez fait pour atteindre le corps de Calculate).

3. Continuez à utiliser F10 pour passer par-dessus chaque ligne jusqu'à ce que vous reveniez à la fonction située dans l'autre fichier, et arrêtez-vous sur la ligne main().

   Le programme fait ce qui est attendu : il prend le premier nombre et le divise par la seconde. Sur la cout ligne, survolez la variable result ou examinez result dans la fenêtre Autos. Sa valeur est inf, ce qui ne semble pas correct.

   

   L’instruction actuelle dans le débogueur est cout << « Result is : » << result << endl ; Dans la fenêtre automatique, le résultat est inf.

   Nous allons résoudre ce problème. La cout ligne affiche la valeur stockée dans result, donc lorsque vous avancez d'une ligne supplémentaire en utilisant F10, la fenêtre de console affiche :

   

   Sorties de l’application : entrez l’opération à effectuer. Format : a+b | a-b | a*b | a/b. L’utilisateur a entré 5-0. Sortie de l’application : Résultat : 5. L’utilisateur a entré 10/0. Sortie de l’application : Résultat : inf

   Ce résultat est dû au fait que la division par zéro n’est pas définie, de sorte que le programme n’a pas de réponse numérique pour l’opération demandée.

Correction de l’erreur « diviser par zéro »

Nous allons gérer la division par zéro plus élégamment pour faciliter la compréhension du problème par l'utilisateur.

1. Apportez les modifications suivantes dans CalculatorTutorial.cpp. Vous pouvez laisser le programme en cours d’exécution lors de la modification, grâce à une fonctionnalité de débogueur appelée Edit and Continue. Ajoutez une if instruction suivante cin >> x >> oper >> y; pour vérifier la division par zéro et générer un message à l’utilisateur s’il se produit. Sinon, le résultat est imprimé.

   // CalculatorTutorial.cpp : This file contains the 'main' function. Program execution begins and ends there.
   //
   
   #include <iostream>
   #include "Calculator.h"
   
   using namespace std;
   
   int main()
   {
       double x = 0.0;
       double y = 0.0;
       double result = 0.0;
       char oper = '+';
   
       cout << "Calculator Console Application" << endl << endl;
       cout << "Please enter the operation to perform. Format: a+b | a-b | a*b | a/b" << endl;
   
       Calculator c;
       while (true)
       {
           cin >> x >> oper >> y;
           if (oper == '/' && y == 0)
           {
               cout << "Math error: Attempted to divide by zero!" << endl;
               continue;
           }
           else
           {
               result = c.Calculate(x, oper, y);
           }
           cout << "Result " << "of " << x << oper << y << " is: " << result << endl;
       }
   
       return 0;
   }
   

2. Appuyez une fois sur F5 . L’exécution du programme continue jusqu’à ce qu’elle soit suspendue pour demander l’entrée de l’utilisateur. Entrez 10 / 0 à nouveau. À présent, un message plus utile est imprimé. L’utilisateur est invité à entrer davantage d’entrée et le programme continue à s’exécuter normalement.

   

   La fenêtre de console affiche deux lignes : 10 / 0 Résultat : inf, suivi d’une erreur mathématique 10 / 0 : Tentative de division par zéro.

   Remarque

   Lorsque vous modifiez du code en mode débogage, il y a un risque que le code devienne obsolète. Cela se produit lorsque le débogueur exécute toujours votre ancien code et qu’il n’a pas encore été mis à jour avec vos modifications. Le débogueur affiche une boîte de dialogue pour vous informer lorsque cela se produit. Parfois, vous devrez peut-être appuyer sur F5 pour actualiser le code en cours d’exécution. En particulier, si vous apportez une modification à l’intérieur d’une fonction alors que le point d’exécution se trouve à l’intérieur de cette fonction, vous devez sortir de la fonction, puis revenir en arrière pour obtenir le code mis à jour. Si cela ne fonctionne pas et que vous voyez un message d’erreur, vous pouvez arrêter le débogage en cliquant sur le carré rouge dans la barre d’outils sous les menus en haut de l’IDE, puis recommencer à déboguer en entrant F5 ou en choisissant la flèche verte « lire » en regard du bouton d’arrêt de la barre d’outils.

   Une autre raison pour laquelle la modification et la poursuite peuvent échouer est si vous voyez un message indiquant que « Les fichiers sources requis pour correspondre exactement au paramètre de version d’origine sous Debug-Options-General>> doivent être activés... » Pour résoudre ce problème, dans le menu principal, sélectionnez>Le débogage>des options> d’outilsen général et assurez-vous que Exiger que les fichiers sources correspondent exactement à la version d’origine soit cochée.

   Présentation des raccourcis d’exécution et de débogage

   • F5 ou Déboguer>Démarrer le débogage, démarre une session de débogage, si elle n’est pas déjà active, et exécute le programme jusqu’à ce qu’un point d’arrêt soit atteint ou que le programme ait besoin d’une entrée utilisateur. Si aucune entrée utilisateur n’est nécessaire et qu’aucun point d’arrêt n’est disponible, le programme se termine et la fenêtre de console se ferme une fois le programme en cours d’exécution. Si votre programme envoie des sorties vers la console, utilisez Ctrl+F5 ou définissez un point d'arrêt avant d'appuyer sur F5 pour maintenir la fenêtre ouverte.
   • Ctrl+F5, ou Déboguer>Démarrer sans débogage, exécute l’application sans qu'elle passe en mode débogage. Cela est légèrement plus rapide que le débogage, et la fenêtre de console reste ouverte une fois que le programme a terminé l’exécution.
   • F10, appelé Pas à pas, vous permet d’itérer dans le code, la ligne par ligne et de visualiser la façon dont le code est exécuté et quelles valeurs de variable sont à chaque étape de l’exécution.
   • F11, appelé Step Into, fonctionne de la même façon que Step Over, sauf qu’il effectue des étapes dans toutes les fonctions appelées sur la ligne d’exécution. Par exemple, si la ligne exécutée appelle une fonction, appuyez sur F11 pour déplacer le pointeur dans le corps de la fonction. Vous pouvez donc suivre le code de la fonction en cours d’exécution avant de revenir à la ligne à laquelle vous avez commencé. Appuyez sur les étapes F10 sur l’appel de fonction et passez simplement à la ligne suivante ; l’appel de fonction se produit toujours, mais le programme ne s’interrompt pas pour vous montrer ce qu’il fait.

Fermer l’application

• Si elle est toujours en cours d’exécution, fermez la fenêtre de console pour arrêter l’application de calculatrice.

Ajouter un contrôle de code source Git

Maintenant que vous avez créé une application, vous pouvez l’ajouter à un dépôt Git. Nous nous occupons de tout. Visual Studio facilite ce processus avec les outils Git que vous pouvez utiliser directement à partir de l’IDE.

Conseil / Astuce

Git est le système de contrôle de version moderne le plus utilisé. Par conséquent, que vous soyez développeur professionnel ou que vous appreniez à coder, Git peut être très utile. Si vous débutez avec Git, le site web https://git-scm.com/ est un bon point de départ. Là, vous trouverez des feuilles de triche, un livre en ligne populaire et des vidéos Git Basics.

Pour associer votre code à Git, commencez par créer un dépôt Git où se trouve votre code. Voici comment procéder :

1. Dans la barre d’état située en bas à droite de Visual Studio, sélectionnez Ajouter au contrôle de code source, puis sélectionnez Git.

   

2. Dans la boîte de dialogue Créer un dépôt Git , connectez-vous à GitHub.

   

   Le nom du référentiel est renseigné automatiquement en fonction de l’emplacement de votre dossier. Par défaut, votre nouveau référentiel est privé, ce qui signifie que vous êtes le seul à y accéder.

   Conseil / Astuce

   Que votre référentiel soit public ou privé, il est préférable d’avoir une sauvegarde à distance de votre code stockée en toute sécurité sur GitHub. Même si vous ne travaillez pas avec une équipe, un référentiel distant met votre code à votre disposition à partir d’un ordinateur.

3. Sélectionnez Créer et envoyer (push).

   Une fois que vous avez créé votre référentiel, les détails de l’état apparaissent dans la barre d’état.

   

   La première icône avec les flèches indique le nombre de validations sortantes/entrantes dans votre branche actuelle. Vous pouvez utiliser cette icône pour extraire les validations entrantes ou envoyer (push) des validations sortantes. Vous pouvez également choisir d’afficher ces validations en premier. Pour ce faire, sélectionnez l’icône, puis sélectionnez Afficher les entrées sortantes/entrantes.

   La deuxième icône avec le crayon affiche le nombre de modifications non validées apportées à votre code. Vous pouvez sélectionner cette icône pour afficher ces modifications dans la fenêtre Modifications Git.

Pour en savoir plus sur l’utilisation de Git avec votre application, consultez la documentation sur le contrôle de version de Visual Studio.

L’application terminée

Félicitations! Vous avez terminé le code de l’application de calculatrice, créé et débogué, puis l’avez ajouté à un dépôt, dans Visual Studio.

Étapes suivantes

En savoir plus sur Visual Studio pour C++