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 allez commencer par cela dans cet article, puis nous allons passer à quelque chose de plus difficile : une application de calculatrice.

Prérequis

• Visual Studio avec le développement Desktop avec la charge de travail C++ installée et en cours d’exécution sur votre ordinateur. Pour l’installer, consultez La prise en charge d’Installer C++ dans Visual Studio.
• Ce tutoriel présente une fonctionnalité appelée Modifier et continuer qui permet de modifier votre code pendant l’exécution de l’application. Pour activer la modification et continuer, dans le menu principal, sélectionnez Le débogage>des options>d’outils>en général et assurez-vous que Exiger que les fichiers sources correspondent exactement à la version d’origine est case activée ed.

Créer un 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 le lien entre tous les fichiers d’un projet et les éventuels 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 liste des modèles de projet, sélectionnez Application console, puis Sélectionnez Suivant.

   

   Important

   Veillez à sélectionner la version C++ du modèle d’application console. Elle présente les mots clés 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 les entrées 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 la génération et l’exécution de la nouvelle application se déroulent normalement

Le modèle d’une nouvelle application console Windows crée une application C++ « Hello World » simple. À ce stade, vous pouvez voir que Visual Studio génère et exécute les applications que vous créez directement dans 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 de la génération.

   

2. Pour exécuter le code, dans la barre de menus, sélectionnez Déboguer, Démarrer sans débogage (Ctrl+F5).

   

   Une fenêtre de console s’ouvre, puis exécute votre application.

   Quand vous démarrez une application console dans Visual Studio, celui-ci exécute votre code, puis affiche le message « Appuyez sur une touche pour fermer cette fenêtre. . afin de vous permettre 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 fermer la fenêtre de console et revenir à Visual Studio.

Vous disposez maintenant des outils nécessaires pour générer et exécuter votre application après chaque modification, dans le but de vérifier que le code fonctionne toujours comme prévu. Nous expliquons ultérieurement comment effectuer le débogage 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 fichier CalculatorTutorial.cpp par le code suivant conformément à 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
   

   Explication du code :

   • Les instructions #include vous permettent de référencer le code situé dans d’autres fichiers. Parfois, vous pouvez voir un nom de fichier entouré de crochets pointus (<>) et parfois, entouré de guillemets doubles (" "). En règle générale, les crochets pointus sont utilisés lors du référencement de la bibliothèque C++ standard. Les guillemets doubles sont utilisés pour les autres fichiers.
   • La ligne using namespace std; indique au compilateur qu’il doit s’attendre à ce que des éléments de la bibliothèque C++ standard soient utilisés dans ce fichier. Sans cette ligne, chaque mot clé de la bibliothèque doit être précédé de std:: pour indiquer l’étendue. Par exemple, sans cette ligne, chaque référence à cout devrait être écrite ainsi : std::cout. L’instruction using est ajoutée pour rendre le code plus clair.
   • Le mot clé cout est utilisé pour afficher la sortie standard en C++. L’opérateur << indique au compilateur d’envoyer tout ce qui est à sa droite vers la sortie standard.
   • Le mot clé endl est similaire à la touche Entrée. Il indique la fin de la ligne et déplace le curseur à la ligne suivante. Il est préférable de placer une \n chaîne à l’intérieur (contenue par "") pour faire la même chose, car endl toujours vide la mémoire tampon qui peut nuire aux performances du programme. Mais comme il s’agit d’une très petite application, endl est utilisé à la place pour une meilleure lisibilité.
   • Toutes les instructions C++ doivent se terminer par des points-virgules et toutes les applications C++ doivent contenir une fonction main(). Cette fonction est exécutée par le programme au démarrage. Pour pouvoir être utilisé, tout le code doit être accessible à partir de main().

2. Pour enregistrer le fichier, appuyez sur Ctrl+S ou sélectionnez l’icône Enregistrer en haut de l’IDE, 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. Vous devriez voir apparaître une fenêtre de console affichant le texte spécifié dans le code.

4. Lorsque vous avez terminé, fermez la fenêtre de console.

Ajouter du code pour effectuer des calculs

Une classe est comme le blueprint d’un objet chargé d’une action. 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 d’édition Nom de la classe, entrez Calculator. Cliquez sur OK.

   

   Le champ nom de classe est défini sur calculatrice. Le champ de fichier .h contient Calculator.h. Le champ de fichier .cpp contient Calculator.cpp. Le champ de classe de base est vide. D’autres options pour le destructeur virtuel, inline et non managé sont non gérées case activée.

   Deux nouveaux fichiers sont ajoutés à votre projet. Pour enregistrer simultanément tous vos fichiers modifiés, appuyez sur Ctrl + Maj + S. Il s’agit du raccourci clavier pour Fichier>Enregistrer tout. La barre d’outils comprend également un bouton Enregistrer tout, représenté par deux disquettes, qui se trouve à côté du bouton Enregistrer. En général, il est recommandé de cliquer régulièrement sur Enregistrer tout pour ne rater aucun fichier lorsque vous enregistrez.

   L’Assistant Ajouter une classe crée et .cpp des .h fichiers portant le même nom que la classe. Vous pouvez voir la liste complète de vos fichiers projet dans la fenêtre Explorateur de solutions qui s’affiche sur le côté de l’IDE. Si la fenêtre n’est pas visible, vous pouvez l’ouvrir à partir de la barre de menus : sélectionnez Affichage> 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 de Calculator.h par le code suivant afin que le fichier ressemble à cet exemple :

   #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, que nous allons utiliser pour effectuer des opérations mathématiques d’additions, de soustractions, de multiplications et de divisions.
   • Le code C++ est organisé en fichiers en-tête (.h) et source (.cpp). D’autres extensions de fichier sont prises en charge par différents compilateurs, mais il s’agit là des principales extensions à connaître. Les fonctions et les variables sont normalement déclarées (c’est-à-dire qu’un nom et un type leur sont attribués) dans les fichiers d’en-tête, et sont implémentées (ou définies) dans les fichiers sources. Pour accéder au code défini dans un autre fichier, vous pouvez utiliser #include "filename.h", où filename.h correspond au nom du fichier qui déclare les variables ou les fonctions que vous souhaitez utiliser.
   • Il est conseillé d’organiser votre code dans différents fichiers en fonction de son utilité. Vous pourrez ainsi le retrouver plus facilement quand vous en aurez besoin. Ici, nous définissons la classe Calculator séparément du fichier qui contient la fonction main(), mais nous prévoyons de référencer la classe Calculator 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 le tournevis qui s’affiche, puis sélectionnez Créer une définition de « Calculate » dans Calculator.cpp.

   

   Ce code est ajouté à Calculator.cpp:

   

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

   Pour l’instant, il retourne seulement 0.0. Nous allons y remédier.

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

   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 consomme un nombre, un opérateur et un deuxième nombre, puis exécute l’opération demandée sur les nombres.
   • L’instruction switch vérifie quel opérateur a été fourni et exécute uniquement le cas correspondant à cette opération. Le cas default: peut servir de solution de secours si l’utilisateur tape un opérateur qui n’est pas accepté, pour éviter que le programme ne s’arrête. En règle générale, il est préférable de gérer les entrées d’utilisateur non valides de façon plus élégante, mais cela n’entre pas dans le cadre de ce tutoriel.
   • Le mot clé double désigne un type de nombre qui prend en charge les décimales. De cette façon, la calculatrice peut gérer à la fois les calculs de décimales et les calculs d’entiers. La fonction Calculate doit toujours retourner un tel nombre en raison du double situé au tout début du code (qui indique le type de retour de la fonction). C’est pour cette raison que 0.0 est retourné, même dans le cas par défaut.
   • Le fichier .h déclare la fonction prototype, qui indique initialement au compilateur les paramètres dont il a besoin et le type de retour auquel s’attendre. Le fichier .cpp comprend tous les détails d’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 main fonction comme CalculatorTutorial.cpp 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

   • Dans la mesure où les programmes C++ commencent toujours à la fonction main(), nous devons appeler notre autre code. Une instruction #include est donc nécessaire.
   • Certaines variables initiales (x, y, oper et result) sont déclarées pour stocker respectivement le premier nombre, le deuxième nombre, l’opérateur et le résultat final. 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 ligne Calculator c; déclare un objet nommé « c » comme une instance de la classe Calculator. La classe n’est qu’un blueprint du fonctionnement de la calculatrice. C’est l’objet calculatrice qui effectue les calculs.
   • L’instruction while (true) est une boucle. Le code à l’intérieur de la boucle continue de s’exécuter indéfiniment tant que la condition à l’intérieur de () contient la valeur true. Dans la mesure où la condition est simplement listée comme true, elle reste toujours vraie. La boucle s’exécute donc indéfiniment. Pour fermer le programme, l’utilisateur doit fermer manuellement la fenêtre de console. Sinon, le programme continuera d’attendre une nouvelle entrée.
   • Le mot clé cin est utilisé pour accepter l’entrée de l’utilisateur. Ce flux d’entrée est suffisamment intelligent pour traiter une ligne de texte entrée dans la fenêtre de console et pour la placer à l’intérieur de chacune des variables listées (dans l’ordre), en supposant que l’entrée utilisateur corresponde à la spécification nécessaire. Vous pouvez modifier cette ligne pour accepter différents types d’entrées, comme plus de deux nombres. Cependant la fonction Calculate() doit également être mise à jour pour gérer cette situation.
   • L’expression c.Calculate(x, oper, y); appelle la fonction Calculate définie précédemment, et fournit les valeurs d’entrée que vous avez tapées. La fonction retourne ensuite un nombre qui est stocké dans result.
   • Enfin, result est affiché dans la console pour que l’utilisateur puisse voir le résultat du calcul.

Générer et tester à nouveau le contrôle

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

1. Appuyez sur Ctrl+F5 pour regénérer et démarrer l’application.

2. Entrez 5+5, puis appuyez sur Entrée. Vérifiez que le résultat est bien 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

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 sur la barre grise verticale située sur le bord gauche de la fenêtre de l’éditeur. Un point rouge apparaît.

   

   Maintenant, lorsque nous débogueons le programme, l’exécution s’interrompt à cette ligne. Nous savons déjà que le programme fonctionne pour les 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, entrez (y == 0) && (oper == '/'). Sélectionnez le bouton Fermer pour enregistrer la condition de point d’arrêt.

   

   La condition du point d’arrêt est la suivante : y==0 && oper == '/' Est true.

   À 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 avec l’icône de flèche verte. Dans votre application de console, si vous entrez quelque chose comme « 5-0 », le programme se comporte normalement et continue de s’exécuter. Toutefois, si vous tapez « 10 / 0 », il s’arrête 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 du débogueur

Lorsque vous déboguez votre code, vous remarquerez peut-être que certaines nouvelles fenêtres apparaissent. Ces fenêtres peuvent vous aider lors du débogage. Intéressons-nous à la fenêtre Automatique. La fenêtre Automatique montre les valeurs actuelles des variables qui sont utilisées au moins trois lignes avant la ligne actuelle.

La valeur de l’opérateur est 47 '/', 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 Variables locales. Vous pouvez modifier les valeurs de ces variables lors du débogage pour voir quel effet ils auraient sur le programme. Dans ce cas, nous les ignorons.

La valeur de l’opérateur 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. Cliquez sur la fenêtre d’éditeur pour la mettre en mode focus.

Poursuivre le débogage

1. La flèche jaune à gauche montre le point d’exécution actuel. La ligne actuelle appelle Calculate. Par conséquent, appuyez sur F11 pour effectuer un pas à pas détaillé de la fonction. Vous exécutez maintenant le code dans le corps de la fonction Calculate. Soyez prudent avec l’option Effectuer un pas à pas détaillé, car vous effectuez alors un pas à pas détaillé pour l’ensemble des fonctions de la ligne où vous vous trouvez, y compris pour les fonctions de bibliothèque standard. Il est possible d’effectuer un pas à pas détaillé dans la bibliothèque standard, cependant il est plus intéressant de se concentrer sur votre code que sur le code de la bibliothèque.

2. Maintenant que le point d’exécution se trouve au début de la fonction Calculate, appuyez sur F10 pour passer à la ligne suivante dans l’exécution du programme. F10 correspond également à Pas à pas principal. Vous pouvez utiliser le pas à pas principal pour passer d’une ligne à l’autre, sans entrer dans les détails de ce qui se produit dans chaque partie de la ligne. En général, il est préférable d’utiliser l’option Pas à pas principal plutôt que Effectuer un pas à pas détaillé, sauf si vous souhaitez analyser davantage le code qui est appelé à partir d’un autre emplacement (comme vous l’avez fait pour atteindre le corps de Calculate).

3. Continuez à utiliser F10 pour effectuer un pas à pas principal sur chaque ligne, jusqu’à ce que vous retourniez à la fonction main() de l’autre fichier et que vous vous arrêtiez à la ligne cout.

   Le programme fait ce qui est attendu : il prend le premier nombre et le divise par la seconde. Sur la ligne cout, pointez sur la variable result ou regardez result dans la fenêtre Automatique. La valeur inf n’est pas correcte, nous allons donc la corriger. La ligne cout ne fait que générer la valeur qui est stockée dans result. Ainsi, lorsque vous avancez d’une ligne à l’aide de F10, la fenêtre de console affiche :

   

   Sortie 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 THe est 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.

Corriger l’erreur de division par zéro

Nous allons traiter le problème de la division par zéro d’une façon plus appropriée afin que cela soit mieux compréhensible pour l’utilisateur.

1. Dans CalculatorTutorial.cpp, effectuez les changements suivants. (vous pouvez laisser le programme s’exécuter pendant que vous le modifiez, grâce à une fonctionnalité du débogueur appelée Modifier et continuer). Ajoutez une if instruction suivante cin >> x >> oper >> y; à case activée pour la division par zéro et affichez un message à l’utilisateur s’il se produit. Dans le cas contraire, 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 << "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’il doive s’interrompre pour demander une entrée utilisateur. Entrez à nouveau 10 / 0. Maintenant, un message plus utile s’affiche. L’utilisateur est invité à taper une entrée supplémentaire, et le programme continue de 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

   Quand 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 le code qu’il n’a pas encore mis à jour. Quand cela se produit, le débogueur affiche une boîte de dialogue pour vous en informer. Parfois, vous devrez appuyer sur F5 pour actualiser le code exécuté. Si vous apportez une modification au sein d’une fonction alors que le point d’exécution se trouve à l’intérieur de cette fonction, vous devez effectuer un pas à pas sortant sur la fonction, puis retournez-y 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’outils>en général et assurez-vous que exiger des fichiers sources correspondant exactement à la version d’origine est case activée ed.

   Comprendre les raccourcis d’exécution et de débogage

   • F5 (qui correspond à Déboguer>Démarrer le débogage) démarre une session de débogage si aucune n’est déjà active, puis exécute le programme jusqu’à ce qu’un point d’arrêt soit atteint ou qu’une entrée utilisateur soit nécessaire. Si aucune entrée utilisateur n’est nécessaire et qu’aucun point d’arrêt ne peut être atteint, l’exécution du programme prend fin et la fenêtre de console se ferme. Si vous devez exécuter un programme du type « Hello World », utilisez Ctrl + F5 ou définissez un point d’arrêt avant d’appuyer sur F5 pour maintenir la fenêtre ouverte.
   • CTRL + F5 (qui correspond à Déboguer>Démarrer sans débogage) exécute l’application sans passer en mode débogage. Ce processus est légèrement plus rapide que le débogage, et la fenêtre de console reste ouverte lorsque l’exécution du programme est terminée.
   • F10 (qui correspond au pas à pas principal) permet d’itérer le code, ligne par ligne, ainsi que de visualiser la façon dont le code est exécuté et quelles sont les valeurs des variables à chaque étape de l’exécution.
   • F11 (qui correspond au pas à pas détaillé) fonctionne de façon similaire au pas à pas principal, sauf qu’il parcourt toutes les fonctions appelées sur la ligne de l’exécution. Par exemple, si la ligne en cours d’exécution appelle une fonction, le fait d’appuyer sur F11 déplace le pointeur dans le corps de la fonction, afin que vous puissiez suivre le code de la fonction en cours d’exécution avant de revenir à la ligne où vous avez démarré. Le fait d’appuyer sur F10 effectue un pas à pas principal sur l’appel de fonction et passe à 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

• Fermez la fenêtre de console de l’application de calculatrice si celle-ci est toujours en cours d’exécution.

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

Git étant le système de gestion de version moderne le plus utilisé, 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. Vous y trouverez des aide-mémoire, un livre en ligne populaire et des vidéos Git Basics pour acquérir les bases de Git.

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

1. Dans la barre d’état 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 dépôt est privé, ce qui signifie que vous seul pouvez y accéder.

   Conseil

   Que votre dépôt 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 dépôt distant rend votre code disponible à partir de n’importe quel ordinateur.

3. Sélectionnez Créer et faire un 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 commits sortants/entrants dans votre branche actuelle. Vous pouvez utiliser cette icône pour extraire les commits entrants ou envoyer (push) des commits sortants. Vous pouvez également choisir d’afficher ces commits en premier. Pour ce faire, sélectionnez l’icône, puis choisissez View Outgoing/Incoming (Afficher les éléments entrants/sortants).

   La deuxième icône avec le crayon indique 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 relative au 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++