Ci-dessous, les différences entre deux révisions de la page.
Les deux révisions précédentes Révision précédente Prochaine révision | Révision précédente | ||
bloc1:csharpa1 [2021/09/28 23:21] techer.charles_educ-valadon-limoges.fr [Saisie de la valeur à chercher] |
bloc1:csharpa1 [2021/09/30 11:41] (Version actuelle) techer.charles_educ-valadon-limoges.fr [Outil de débogage :] |
||
---|---|---|---|
Ligne 91: | Ligne 91: | ||
Vérifiez si vous arrivez à saisir puis si l' | Vérifiez si vous arrivez à saisir puis si l' | ||
</ | </ | ||
+ | {{ : | ||
===== Etape 2 ===== | ===== Etape 2 ===== | ||
- | Saisie d'un premier essai | + | ==== Saisie d'un premier essai ==== |
- | Maintenant que l' | + | Maintenant que l' |
- | Le principe va être le même que p récédemment | + | |
+ | Le principe va être le même que précédemment | ||
+ | * il faut afficher un message | ||
+ | * et mémoriser la saisie dans une nouvelle variable. | ||
+ | Il faut utiliser | ||
+ | <code c#> | ||
// saisie du premier essai | // saisie du premier essai | ||
Console.Write(" | Console.Write(" | ||
essai = int.Parse(Console.ReadLine()); | essai = int.Parse(Console.ReadLine()); | ||
- | Remarquez que 'essai' | + | </ |
+ | Remarquez que **essai** est soulignée en rouge. C'est normal et vous devriez savoir pourquoi.: la variable n'est pas déclarée. Ajoutez sa déclaration, | ||
+ | <code c#> | ||
// déclaration | // déclaration | ||
int valeur, essai; | int valeur, essai; | ||
+ | </ | ||
Lorsque plusieurs variables sont de même type, il est possible de les déclarer sur la même ligne. Vous pouvez aussi faire une ligne par déclaration. Maintenant, il n'y a plus d' | Lorsque plusieurs variables sont de même type, il est possible de les déclarer sur la même ligne. Vous pouvez aussi faire une ligne par déclaration. Maintenant, il n'y a plus d' | ||
- | Test | + | |
+ | <WRAP center round todo> | ||
+ | **Test** | ||
Vous pouvez saisir la valeur à chercher, puis l' | Vous pouvez saisir la valeur à chercher, puis l' | ||
+ | </ | ||
+ | {{ : | ||
+ | ===== Etape 3 ===== | ||
+ | ==== Comparaison de l' | ||
+ | Une fois l' | ||
+ | |||
+ | Il est donc nécessaire de comparer **essai** avec **valeur**. Vous allez ainsi découvrir un nouveau principe de codage : **l' | ||
+ | |||
+ | A la suite du code actuel, ajoutez : | ||
+ | |||
+ | <code c#> | ||
+ | // test de l' | ||
+ | if (essai > valeur) | ||
+ | { | ||
+ | | ||
+ | } | ||
+ | else | ||
+ | { | ||
+ | | ||
+ | } | ||
+ | </ | ||
+ | L' | ||
+ | * le premier bloc s' | ||
+ | * le second bloc (dans le **else**) s' | ||
+ | <WRAP center round todo> | ||
+ | **test** | ||
+ | |||
+ | Vérifiez que vous obtenez bien le message (**trop grand** ou **trop petit**) correspondant à ce qui est attendu. | ||
+ | |||
+ | Par exemple, si la valeur est 57 et l' | ||
+ | Même image que l' | ||
+ | </ | ||
+ | {{ : | ||
+ | ===== Etape 4 ===== | ||
+ | ==== Saisie d'un nouvel essai ? ==== | ||
+ | |||
+ | Il sera nécessaire de saisir plusieurs essais avant de trouver la bonne valeur, sans savoir à l' | ||
+ | |||
+ | Vous allez ainsi découvrir un nouveau principe de codage : **l' | ||
+ | |||
+ | Sur quoi doit-on boucler ? Sur la saisie de l' | ||
+ | <code c#> | ||
+ | while (essai != valeur) | ||
+ | { | ||
+ | // instructions qui vont se répéter | ||
+ | } | ||
+ | </ | ||
+ | Le signe **!=** correspondant à **différent** en mathématique. | ||
+ | |||
+ | Le test se faisant dès le début, il faut qu'un premier essai soit saisi. Puis, dans la boucle, il faut intégrer le test déjà écrit. Mais ensuite, toujours dans la boucle, il faut saisir un nouvel essai : | ||
+ | <code c#> | ||
+ | // saisie du premier essai | ||
+ | Console.Write(" | ||
+ | essai = int.Parse(Console.ReadLine()); | ||
+ | while (essai != valeur) | ||
+ | { | ||
+ | // test de l' | ||
+ | if (essai > valeur) | ||
+ | { | ||
+ | | ||
+ | } | ||
+ | else | ||
+ | { | ||
+ | | ||
+ | } | ||
+ | // saisie d'un nouvel essai | ||
+ | | ||
+ | essai = int.Parse(Console.ReadLine()); | ||
+ | } | ||
+ | </ | ||
+ | Juste après la saisie d'un nouvel essai, l' | ||
+ | <WRAP center round todo> | ||
+ | **test** | ||
+ | |||
+ | Vérifiez qu'à chaque essai saisi, le bon message s' | ||
+ | |||
+ | </ | ||
+ | {{ : | ||
+ | |||
+ | ===== Etape 5 ===== | ||
+ | |||
+ | ==== Valeur trouvée ==== | ||
+ | |||
+ | Après la boucle, et avant que la fenêtre ne se ferme, ce serait bien d' | ||
+ | <code c#> | ||
+ | // valeur trouvée | ||
+ | Console.WriteLine(" | ||
+ | </ | ||
+ | <WRAP center round todo> | ||
+ | **test** | ||
+ | |||
+ | Cette fois, après avoir saisi plusieurs essais, puis la bonne valeur, vous obtenez bien le message **Vous avez trouvé**. | ||
+ | </ | ||
+ | {{ : | ||
+ | |||
+ | ===== Etape 6 ===== | ||
+ | |||
+ | ==== Affichage du nombre de tentatives ==== | ||
+ | |||
+ | Le but est aussi d' | ||
+ | |||
+ | Il faut une autre variable, qu'on va appeler **nbre** et qui doit compter le nombre de tentatives. Comme il y a au moins une tentative (un premier essai saisi avant la boucle), on va directement affecter 1 à cette variable en début de programme, on dit qu'on **initialise la variable**. | ||
+ | |||
+ | Donc, au niveau de la déclaration, | ||
+ | <code c#> | ||
+ | // déclaration | ||
+ | int valeur, essai, nbre = 1; | ||
+ | </ | ||
+ | Arrêtons-nous quelques instants sur cette ligne : | ||
+ | * cette écriture est un raccourci ; | ||
+ | * les 3 variables étant de même type, le type n'est précisé qu'une seule fois et les variables sont séparées par des virgules. | ||
+ | |||
+ | De plus il est possible de déclarer et initialiser des variables en même temps. Cette ligne de code pourrait être écrite en plusieurs fois comme ceci (inutile de modifier le code, c'est juste pour que vous compreniez). | ||
+ | <code c#> | ||
+ | // déclaration | ||
+ | int valeur; | ||
+ | int essai; | ||
+ | int nbre; | ||
+ | nbre = 1; | ||
+ | </ | ||
+ | Ces deux blocs de code sont équivalents. | ||
+ | |||
+ | <WRAP center round info> | ||
+ | Remarquez au passage que **nbre** est souligné en vert : ce n'est pas une erreur mais une information. Si vous mettez la souris dessus sans cliquer, vous obtenez le message "La variable ' | ||
+ | |||
+ | </ | ||
+ | Effectivement on ne l' | ||
+ | <code c#> | ||
+ | nbre = nbre + 1; | ||
+ | </ | ||
+ | On affecte dans ' | ||
+ | <code c#> | ||
+ | nbre++; | ||
+ | </ | ||
+ | Vous allez ajouter cette ligne de code en fin de boucle (dernière ligne de code de la boucle), comme ceci : | ||
+ | <code c#> | ||
+ | // compteur d' | ||
+ | nbre++; | ||
+ | </ | ||
+ | Il reste à afficher le nombre d' | ||
+ | <code c#> | ||
+ | // valeur trouvée | ||
+ | Console.WriteLine(" | ||
+ | </ | ||
+ | <WRAP center round todo> | ||
+ | **test** | ||
+ | |||
+ | Vérifiez qu'au final, vous obtenez le message **Vous avez trouve en nbre fois !** | ||
+ | </ | ||
+ | |||
+ | Ce n'est pas ce que l'on veut : on veut que ce soit le contenu de la variable **nbre** qui soit affiché. | ||
+ | |||
+ | Par exemple, si on a trouvé en 4 fois, on aimerait obtenir : **" | ||
+ | |||
+ | Tout ce qui est entre guillemets est affiché en l' | ||
+ | <code c#> | ||
+ | // valeur trouvée | ||
+ | Console.WriteLine(" | ||
+ | </ | ||
+ | <WRAP center round info 60%> | ||
+ | **test** | ||
+ | Cette fois, vous allez obtenir le bon message, avec le nombre d' | ||
+ | </ | ||
+ | {{ : | ||
+ | |||
+ | ===== Etape 7 ===== | ||
+ | ==== Nettoyage du code ==== | ||
+ | Rappelez-vous que du code a été généré automatiquement dès le début de la création du projet, en particulier les **using** : | ||
+ | {{ : | ||
+ | <WRAP center round info> | ||
+ | Les **using** permettent d' | ||
+ | </ | ||
+ | |||
+ | Vous remarquerez qu' | ||
+ | |||
+ | Cette phase consiste aussi à contrôler qu'il n'y a pas de variable non utilisée (qui apparait en gris). Ce n'est pas le cas ici. | ||
+ | |||
+ | <WRAP center round info> | ||
+ | **test** | ||
+ | |||
+ | Vérifiez que le programme fonctionne toujours correctement. | ||
+ | </ | ||
+ | {{ : | ||
+ | ===== Etape 8 ===== | ||
+ | ==== Ajout de cartouche ==== | ||
+ | Il nous reste à ajouter un tout dernier détail dans le programme : un **cartouche** qui est un commentaire particulier, | ||
+ | |||
+ | Même si le cartouche permet d' | ||
+ | |||
+ | * Placez le curseur tout en haut à droite du fichier et validez pour créer une ligne vide. | ||
+ | * Ajoutez le cartouche suivant (en changeant l' | ||
+ | Remarquez que, dès la saisie de ** %%/**%% **, tout le programme se met en vert, car tout est considéré comme un commentaire, | ||
+ | |||
+ | En validant après **%%/ | ||
+ | <code c#> | ||
+ | /** | ||
+ | * Jeu du nombre caché | ||
+ | * author : votre nom | ||
+ | * date : 23/ | ||
+ | | ||
+ | using System; | ||
+ | </ | ||
+ | Toutes ces modifications ne doivent rien changer à l' | ||
+ | |||
+ | Voici le programme complet. | ||
+ | <WRAP center round todo> | ||
+ | **test** | ||
+ | Vérifiez que le programme fonctionne toujours correctement. | ||
+ | |||
+ | </ | ||
+ | {{ : | ||
+ | |||
+ | ===== Etape 9 ===== | ||
+ | |||
+ | ==== Tests de l' | ||
+ | |||
+ | Lorsqu' | ||
+ | |||
+ | Le but est de voir si le programme fonctionne quelle que soit la situation. Il est généralement impossible de tester | ||
+ | |||
+ | Dans l' | ||
+ | * trouver la valeur en plusieurs essais (cas classique) ; | ||
+ | * trouver la valeur au premier essai (cas particulier car le premier essai a été traité différemment, | ||
+ | * saisir un caractère au lieu d'un nombre (comportement inattendu). | ||
+ | <WRAP center round todo> | ||
+ | **test** | ||
+ | Essayez les 2 premiers cas qui ne doivent pas poser de problème. Essayez ensuite le dernier cas en tapant une lettre au lieu d'un nombre (dans la valeur, mais le problème sera identique dans l' | ||
+ | </ | ||
+ | |||
+ | Le programme s' | ||
+ | <code c#> | ||
+ | valeur = int.Parse(Console.ReadLine()); | ||
+ | </ | ||
+ | et le message d' | ||
+ | |||
+ | La ligne de code permet de réaliser une saisie, puis de la transformer (**transtyper**) en type **int** (entier) pour pouvoir l' | ||
+ | |||
+ | Le problème vient du fait qu'une lettre est saisie et que le programme tente de la convertir en **int**, ce qui n'est pas possible. | ||
+ | |||
+ | Pour éviter l' | ||
+ | {{ : | ||
+ | |||
+ | ==== Tests de l' | ||
+ | Voilà comment fonctionne la capture d' | ||
+ | <code c#> | ||
+ | try | ||
+ | { | ||
+ | // contenant le code qui peut poser problème | ||
+ | } | ||
+ | catch | ||
+ | { | ||
+ | // contenant le code à exécuter, en cas d' | ||
+ | } | ||
+ | </ | ||
+ | Commençons par la première saisie (valeur). L' | ||
+ | <code c#> | ||
+ | bool correct = false; | ||
+ | // saisie du nombre à chercher | ||
+ | while (!correct) | ||
+ | { | ||
+ | try | ||
+ | { | ||
+ | Console.Write(" | ||
+ | valeur = int.Parse(Console.ReadLine()); | ||
+ | correct = true; | ||
+ | } | ||
+ | catch | ||
+ | { | ||
+ | Console.WriteLine(" | ||
+ | } | ||
+ | } | ||
+ | Console.Clear(); | ||
+ | </ | ||
+ | Le signe " | ||
+ | Remarquez une nouvelle erreur : sur la ligne de code "while (essai != valeur)", | ||
+ | <WRAP center round todo> | ||
+ | **test** | ||
+ | |||
+ | Vérifiez qu'en saisissant une lettre, le message d' | ||
+ | |||
+ | </ | ||
+ | Faites les mêmes modifications pour la saisie de l' | ||
+ | <WRAP center round important> | ||
+ | **test** | ||
+ | |||
+ | Vérifiez que tout le programme fonctionne correctement. Essayez de saisir une lettre lors du premier essai, et aussi lors des essais suivants. Vérifiez aussi que le nombre d' | ||
+ | </ | ||
+ | |||
+ | Vous avez remarqué que du code se répète : vous apprendrez plus tard comment optimiser le code pour éviter ce genre de répétition. | ||
+ | {{ : | ||
+ | |||
+ | ===== Etape 10 ===== | ||
+ | |||
+ | ==== Outil de débogage : ==== | ||
+ | |||
+ | Tous les IDE possèdent un outil de débogage qui permet une exécution pas à pas du programme avec vérification de l' | ||
+ | |||
+ | Même si le programme est opérationnel, | ||
+ | === Point d' | ||
+ | Il est possible de placer un ou plusieurs points d' | ||
+ | {{ : | ||
+ | La ligne du point d' | ||
+ | === Démarrage du débogueur : === | ||
+ | |||
+ | Il est alors possible de lancer le débogueur : menu " | ||
+ | {{ : | ||
+ | A partir de là, vous allez pouvoir consulter l' | ||
+ | === Etat des variables : === | ||
+ | |||
+ | Maintenant que le programme s'est arrêté, observez la fenêtre du bas qui donne l' | ||
+ | {{ : | ||
+ | Ne tenez pas compte de ' | ||
+ | |||
+ | === Exécution pas à pas : === | ||
+ | |||
+ | Vous allez maintenant avancer dans l' | ||
+ | {{ : | ||
+ | Cela permet de repérer les changements qui viennent de se faire. | ||
+ | |||
+ | Continuez d' | ||
+ | {{ : | ||
+ | === Exécution rapide ou arrêt : === | ||
+ | |||
+ | A tout moment, il est possible d' | ||
+ |