Compilation d'une boucle switch + Char

Version imprimable

25/08/2019, 21h10
mikelan

2 pièce(s) jointe(s)

Compilation d'une boucle switch + Char

bonjour, je suis en apprentissage C++, j'ai besoin d'aide pour la compilation d'un " Tant que( while) et Cie."

Mais je comprends pas l'erreur. Merci pour votre aide ,meme simple vous parait-il... :roll::roll:

Pièce jointe 499458 Pièce jointe 499460
25/08/2019, 21h41
dalfab

Bonjour,

Il y a en effet des erreurs:
- tu n'as pas compris la syntaxe d'un do { sequence } while(condition_pour_recommencer);. Il n'y a jamais d'expression en parenthèse après le do, c'est toujours après le while. Et peut-être voulais-tu faire un simple if?
- Pour tester si deux chaines sont égales, on ne peut pas écrire "reponse" == "oui", reponse est une variable et "oui" une chaîne. Aucune raison de mettre des guillemets autour d'une variable.
- Pour que reponse contienne la réponse, il faut la mettre à un moment. Il n'y a aucune magie qui fasse que reponse se remplisse spontanément avant la comparaison.
- tu n'as pas compris comment fonctionne un switch(expression_a_rechercher) { case X: .......}. Après chaque case il faut mettre une constante qui peut être un nombre entier ou un caractère, il sera comparé à ce qui est entre les parenthèse du switch, rien d'autre.

Il y a peut-être d'autres erreurs. Le code doit être mis entre balises (bouton [ # ]), merci d'éviter les copies d'écran c'est très pénible à lire, et empêche de te donner de réponses précises.
26/08/2019, 09h02
mikelan

Merci, dalfab,

mon but est de crée un boucle variée:

-faire .... si la réponse est "oui" (recommencer le programme entièrement+remise a 0)

-initier le compteur
-*saisir char
-décompte du compteur -1
-comparaison du char (oui afficher+demander une réponse , non...-->
-->>comparaison du char (oui afficher - non afficher)

-vérification d'un compteur

=0 ->sortie de boucle +demander une réponse

!=0 ->recommencer la saisie*)

(réponse = oui -->recommencer et ré-initier le compteur
non --> sortie du prog.)

si ca peut t'aider a me corriger.

si t'as des conseils la dessus

Salut, et bienvenue sur le forum

D'abord et avant tout : au lieu de t'emm..der à créer des image de tes différentes fenêtre, lorsque tu dois présenter du code, pourrais tu utiliser le bouton en forme de # qui se trouve juste au dessus de la zone d'édition de ton message (sur la droite de la deuxième ligne de bouton) et faire un copier coller de ton code entre les balises [ CODE ] et [ /CODE ] qui apparaitront :question:

Cela mettra permettra de montrer ton code, en respectant la mise en forme et en proposant une coloration syntaxique de manière plus sympa, parce que cela nous permettra, à nous, de faire un copier coller de ton code au besoin afin de l'analyser à notre aise de notre coté ;)

En faisant une sélection au niveau de la ligne de commande de windows et en appuyant sur les touche <ctrl> + C, tu pourras d'ailleurs utiliser le même principe pour nous indiquer les erreurs émises lors de la compilation ;) :D

Ceci étant dit : C++ est un ensemble de conventions qui doivent -- comme le français -- impérativement être respectées si on veut que tous les interlocuteurs se comprennent : si tu demandes le "machin" à quelqu'un, il y a peu de chance qu'il te passe la cuiller que tu souhaite avoir! C'est exactement la même chose en C++ : si tu donne une instruction qu'il ne comprend pas au compilateur, il n'y a aucune chance qui accepte ce que tu lui dit :P

Par exemple, C++ fournit -- comme beaucoup d'autres langages d'ailleurs -- (entre autres) les trois sortes de boucles "classiques", à savoir:
Les boucles "tant que", qui vérifient si il faut entrer dans la boucle AVANT d'exécuter les instructions de la boucle
les boucles "jusque", qui vérifier s'il faut entrer "une fois de plus" dans la boucle après que les instructions qu'elle contient aient été exécutées et
les boucles "pour" qui permettent de compter le nombre de passage dans la boucle, et qui s'arrêtent quand le compteur atteint une certaine valeur

Les boucles "tant que" vont prendre une forme proche de
Code:

1 2 3 while(<condition_pour_entrer_dans_la_boucle>){ // Ce qu'il faut faire }
avec la particularité que, si la condition pour entrer dans la boucle est fausse dés le départ, la boucle ne sera jamais exécutée.

Les boucles "jusque" vont prendre une forme proche de
Code:

1 2 3 do{ // ce qu'il faut faire }while(<condition_pour_retourner_dans_la_boucle); // !!! n'oublie pas le ;
avec la particularité le fait que la boucle sera au moins exécutée une fois (avant que la condition ne soit vérifiée)
et les boucles "pour" vont prendre une forme proche de
Code:

1 2 3 for(<type> <variable> = <valeur_de_depart>; <condition_pour_continuer>; <calcul_valeur_suivante>){ // ce qu'il faut faire }
avec comme particularité le fait que la boucle sera exécutée le nombre de fois que l'on pourra passer "à la valeur suivante" à partir de "la valeur de départ" en respectant la "condition pour continuer".

Comme tu peux le voir, il n'y a absolument aucune possibilité dans laquelle nous aurions un code proche de
Code:

1 2 3 do (condition){ ce qu'il faut faire } while
Il faut donc commencer par résoudre ce problème en utilisant une des formes de boucle que le compilateur pourra accepter ;)

Ensuite, il faut faire attention au guillemet ", car ils permettent de créer ce que l'on appelle une "chaine littérale". Ainsi, lorsque tu écris le code "reponse" tu crée une chaine de caractères qui contient explicitement les caractères 'r','e','p','o','n','s' et 'e', ce qui n'a absolument rien à voir avec la variable nommée reponse que tu veux justement utiliser pour ton test ;)

Si tu veux tester la valeur d'une variable qui est de type std::string, le test doit prendre la forme de if(nom_de_la_variable == "valeur souhaitée")En outre, le switch ... case ne s'utilise absolument pas comme un test normal, et pour cause : c'est un test dit "à choix multiple": pour une variable donnée, on peut indiquer "plusieurs valeurs" qui permettent d'activer des comportements différents.

La particularité de ce genre de test, c'est que la variable testée doit obligatoirement représenter une valeur numérique entière. La chance, c'est que le type char représente effectivement une valeur numérique entière (correspondant, pour faire simple, à l'indice du "glyphe" représenté dans une table de caractères). Mais le seul moyen d'utiliser ce genre de test serait proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 switch (c){ case 'd' : // ce qu'il faut faire si la variable c représente le caractère d break; case 'f' : // ce qu'il faut faire si la variable c représente le caractère f break; /* ... */ default : // ce qu'il faut faire si la variable c représente n'importe quelle valeur non prise en compte }
Au passage, tu remarqueras que, pour indiquer la valeur d'un caractère unique, on doit utiliser l'apostrophe ' au lieu des guillemets doubles ".

Enfin, on essayera -- autant que possible -- de déclarer les différentes variables aussi près que possible de leur première utilisation, et, si possible, on essayera de leur donner un nom qui correspond à ce que l'on attend de leur part.

Au final, ton code devrait donc ressembler à quelque chose comme
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 int main(){ /* parce que la réponse doit exister au moment du while */ std::string reponse; do{ int count=0; /* parce que l'on a 5 coups maximum */ while(count <5){ /* ce qu'il faut faire tant que nous sommes sur l'un des cinq coup acceptés * par exemple, accepter un caractère */ char choix; /* bla bla */ if(choix <'k'){ // si choix est plus petit que k } else{ // sinon, c'est qu'il est plus grand ou égal à k } } /* arrivé ici, les cinq coups on été joués, que faut-il faire? */ }while(reponse == "oui"); /* arrivé ici, reponse est different de "oui", on va donc quitter l'application */ return 0; }

Bonjour,

Merci pour ces conseils Koala01;

je comprends que la logique doit être TRÈS claire pour la programmation , mais beaucoup de terme a respecter ,

et j'y prends très plaisir a faire( même si a des erreurs....). c'est le début.
Voici mon code : ....corriger ?:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
 
#include <iostream>
#include <string>
 
int main()
 
{    
    std::string reponse;
 
    do{
 
        int count=0;
 
        while(count < 5)
        {
            char c;
            std::cout << " Saisir une lettre : ";
            std::cin >> c;
            count = count + 1;
 
 
            if(c == 'k')
            {
 
                std::cout << "gagne" << std::endl;
                std::cout << "recommencer ?" << std::endl;
                std::cin >> reponse >> std::endl;
            }
 
            else if( c > 'k')
                    {
                        std::cout << "en dessous" << std::endl;
                        std::cout << "perdu" << std::endl;
                        std::cout << "recommencer ?" << std::endl;
                        std::cin >> reponse >> std::endl; 
                    }
            else
            {
                std::cout << "au dessus" << std::endl;
                std::cout << "perdu" << std::endl;
                std::cout << "recommencer ?" << std::endl;
                std::cin >> reponse >> std::endl;
            }  
 
            if (count == 5)
            {
                std::cout << "perdu" << std::endl;
                std::cout << "recommencer ?" << std::endl;
                std::cin >> reponse >> std::endl;
            }
 
        }
 
    }while(reponse == 'oui');
 
    /* je dois recommencer le prog + remise a 0 du "count" /
    
    - je copie a nouveau le code ? */
 
 
 
    return 0;
 
}

Mais comme tu peux le voir, c'est pas encore cohérent. je doute sur un "switch" ou "if".
Pour le "switch" , je n'ai pas tellement de "default"... ou dois je le présenter autrement ?

Merci encore pour ton aide.

27/08/2019, 13h42
koala01

Ce qu'il faut comprendre, c'est que l'ordinateur, c'est un brave petit soldat qui va faire exactement ce qu'on lui dit, sans se poser la moindre question: si on lui dit de sauter, il va sauter. Sans se poser de question. Peu importe si, devant lui, il y a le vide, il sautera quand même.

Le code que tu écris pour lui indiquer ce qu'il doit faire doit donc suivre une logique totalement imparable si tu veux qu'il puisse réagir exactement de la manière don tu t'y attend ;)

Alors, dis moi : lorsque tu as une boucle qui s'assure un compteur (count) est "plus petit que cinq" (c'est exactement ce que tu indique avec le code while count < 5)), quelle chance y a-t-il que, dans la boucle, un test qui s'assure explicitement que count est égal à 5 (c'est ce que tu fais avec la ligne if(count == 5) qui est l'une des instructions effectuée dans la boucle) puisse donné un résultat autre que "faux" :question:

Pire encore, si tu suis la logique "ligne par ligne", et que tu rentre plusieurs fois dans la boucle, quelle sera la valeur de count au moment où toutes les instructions comprises dans la boucle (while(count < 5) ) auront été exécutées :question: Est-ce que le test effectué pour déterminer s'il faut entrer dans la boucle a la moindre chance de donner un résultat autre que vrai :question:

Dans le même ordre d'idée, c'est très bien d'avoir une boucle "jusqu'à" qui s'assure teste la valeur de réponse, mais, quelle est cette valeur au moment du test :question:

Quand tu auras répondu à ces questions et que tu auras corrigé le code en conséquence, tu auras sans doute la réponse aux questions que tu te poses juste avant le return 0 ;)

Un avis , sur la version 2, malgré les questions, j'ai du mal a corriger: :mur: :mur: :mur: :mur: :mur:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
 
#include <iostream>
#include <string>
 
int main()
 
{    
    std::string reponse{};
 
    while(reponse = "oui")
    {
            int count = 5;
 
            do 
            {
 
 
 
                while(count != 0)
                {
 
                    char c;
                    std::cout << " Saisir une lettre : ";
                    std::cin >> c;
 
 
                    if(c == 'k')
                    {
 
                        std::cout << "gagne" << std::endl;
                        std::cout << "recommencer ?" << std::endl;
                        std::cin >> reponse >> std::endl;
 
                    }
 
                    else if( c >= 'k')
                            {
 
                                std::cout << "en dessous" << std::endl;
                                count = count - 1;
 
 
                            }
                    else
                    {
 
                        std::cout << "au dessus" << std::endl;
                        count = count - 1;
 
                    }
 
 
 
                }
 
                if (count == 0)
                {
                    std::cout << "perdu" << std::endl;
                    std::cout << "recommencer ?" << std::endl;
                    std::cin >> reponse >> std::endl;
 
                }
 
            }
    }
 
 
    return 0;
 
}

29/08/2019, 22h48
koala01

à la ligne 11 while(reponse = "oui") assigne la valeur "oui" à la variable reponse, ce n'est pas ce que tu veux faire ;)

a la ligne 15, tu as un do qui indique, de toute évidence, le début d'une boucle "jusque", mais, bien que tu aies l'accolade fermante du bloc qui devrait être exécuté dans cette boucle, tu n'as aucune condition pour indiquer "jusqu'à quand" il faut effectuer la boucle.

à la ligne 13, tu indique explicitement que count vaut 5, et tu persiste, à la ligne 15, en créant une boucle "tant que count n'est pas égal à 0": c'est une possibilité, mais, comme tu ne fais pas varier count à chaque passage dans la boucle, il vaudra 5 "pour l'éternité", et il est donc fort improbable que la boucle s'arrête un jour
29/08/2019, 23h29
koala01
Il faut bien comprendre que, à la base, un ordinateur ne sait pas faire grand chose. Ce qu'il sait faire se limite
- aux quatre opérations de base (addition, soustraction, multiplication et division)
- aux comparaisons de valeurs (plus petit, plus petit ou égal, égal, plus grand ou égal, plus grand)
- à copier le contenu d'une adresse mémoire vers une autre adresse mémoire
- à copier le contenu d'une adresse mémoire vers un registre dans lequel il pourra le manipuler
- à copier le contenu d'un registre vers une adresse mémoire
- à sauter de l'adresse mémoire à laquelle se trouve une instruction "à exécuter" vers une autre adresse mémoire à laquelle se trouve une autre instruction
Et c'est tout!!!

Le pire de tout, c'est que tout ce qu'il peut faire, les instructions qu'il peut exécuter, les valeurs qu'il peut manipuler, sont représentées par le fait que le courant arrive à un point donné du système ou non. C'est la multiplication des points où il peut vérifier si le courant passe ou non qui lui permet de travailler

Il ne sait rien sur rien.

Un langage de programmation -- quel qu'il soit -- nous permet uniquement de représenter les instructions que l'on veut donner à l'ordinateur et les valeurs qu'il doit traiter de manière "plus compréhensible" pour un humain. Pour que l'ordinateur fasse exactement ce que l'on veut, la suite logique des instructions et des données que l'on veut lui faire manipulée doit être absolument parfaite, parce que l'ordinateur ne fera jamais preuve d'initiative, il ne se demandera jamais s'il est effectivement opportun d'effectuer telle instruction plutôt qu'une autre.

Quand tu veux créer un programme, quel qu'il soit, tu dois pouvoir déterminer les données que l'ordinateur devra utiliser ainsi que la valeur que ces données devront représenter afin d'avoir une "situation de départ" connue, et ton programme ne sera que la suite des instructions qui permettront de manière logique d'obtenir une situation finale prévisible et reproductible.

Autrement dit, après avoir écrit ton code, si tu prend un papier et un crayon, suivant pas à pas les instructions dans l'ordre exact dans lequel tu les as codée, et en notant les valeurs des différentes données que tu as fournie, tu devrait pouvoir obtenir le résultat que tu attends de la part de l'ordinateur. Si tu n'obtiens pas le résultat que tu espérais, c'est que ton code n'est tout simplement pas juste.

En outre, tu sera forcément confronté au fait de respecter les conventions imposées par le langage, mais, a priori, lorsque tu vas lancer la compilation (dans le cas du C++ et d'autres langages) ou l'interprétation (dans le cas d'autres langage) du code que tu as écrit, si tu ne respecte pas ces conventions, le compilateur (ou l'interpréteur, selon le cas) t'indiquera clairement qu'il n'a pas compris ce que tu voulais dire, généralement en indiquant très gentiment la ligne à laquelle se trouve ce qu'il n'a pas compris, et parfois en te donnant une indication sur ce qui pourrait convenir.

Quoi qu'il en soit, si tu veux pouvoir écrire du code correct, tu dois, d'abord et avant tout définir l'ordre logique "implacable" qui te permettra, sur base d'une situation donnée, d'obtenir le résultat exact auquel tu t'attends. Parce que tu es le seul maitre à bord ;)

Re bonjour.

Apres quelques heures de reflexion et analyse des tes conseils,
voici en quoi j'arrive.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
 
#include <iostream>
#include <string>
 
int main()
 
{    
    std::string reponse;
 
    do
    {
        char c;
        int count=5;
        std::cout << " Saisir une lettre : ";
        std::cin >> c;
 
 
 
 
        while(reponse == "oui")
 
        {
                char c;
                int count=5;
                std::cout << " Saisir une lettre : ";
                std::cin >> c;
 
 
                    while(count != 0)
 
                    {
 
                                std::cout << " Saisir une lettre : ";
                                std::cin >> c;
 
 
 
                                if(c == 'k')
                                    {
                                        std::cout << "gagne" ;
                                        std::cout << "recommencer ?" ;
                                        std::cin >> reponse;
                                        break;
                                    }
 
                                else if( c >= 'k')
                                    {        
                                                std::cout << "en dessous" ;
                                                count = count - 1;
                                    }
 
                                else 
                                    {
                                        std::cout << "au dessus" ;
                                        count = count - 1; 
                                    }
 
 
 
                    }
 
                                std::cout << "perdu" ;
                                std::cout << "recommencer ?" ;
                                std::cin >> reponse;
        }
 
 
    }
 
 
    return 0 ;
 
}

Je penses que c'est mieux, mais pas encore...... fonctionnelle a 100%.

Voici, l'erreur qu'il m'indique mais la comprends pas l'erreur. Basé sur le "return 0".

Code:

1
2
3
4
5
6
7
8
9
10
11
 
 
C:\Users\MikeL\Desktop\Programmation C++\Test Prog (8)CNFDI1.3>g++ -std=c++14 main2.cpp -o TestCNFDI3
main2.cpp: In function 'int main()':
main2.cpp:70:12: error: expected 'while' before numeric constant
     return 0 ;
            ^
main2.cpp:70:12: error: expected '(' before numeric constant
main2.cpp:70:14: error: expected ')' before ';' token
     return 0 ;
              ^

Puis-je encore vous soliciter ? "Koala01"

(Merci beaucoup de votre aider,j'apprécie.) ;);)

Cordialement.

31/08/2019, 14h25
koala01

ajout du post-scriptum
Profites du fait que ton code est correctement indenté (à part les lignes 63 à 65, dont le texte pourrait commencer juste au niveau de l'accolade fermante de la ligne 61 :P) pour repérer de manière systématique l'accolade fermante associée à chaque accolade ouvrante!

Encore une fois, tu utilises l'instruction do à la ligne 11. Si tu utilises l'instruction do, tu dois respecter le format
Code:

1 2 3 4 do { /* ce qu'il faut faire dans la boucle */ }while(condition_pour_retourner_dans_la_boucle);
L'accolade ouvrante qui indique le début du bloc d'instructions qu'il faut faire pour cette boucle se trouve à la ligne 12, et l'accolade fermante qui lui est associée se trouve à la ligne 69.

Que manque-t-il donc, selon toi, à la ligne 69 pour que le compilateur puisse être content :question:

Mieux encore: pose toi la question de savoir si cette boucle qui commence à la ligne 11 et qui termine à la ligne 69 est vraiment nécessaire, car, après tout, la boucle qui commence à la ligne 20 et qui termine à la ligne 66 va s'effectuer "tant que la réponse est égale à ''oui''.

Au fait, que vaut reponse la première fois que tu testes cette condition :question:

PS: Quand je te pose une question, n'hésites pas à y répondre, pour que je puisse éventuellement t'expliquer quelle erreur tu commets dans ta manière de penser (autrement dit, dans ta logique) ;)

Bien le bonjour, Koala01,

J'ai relu mon code, avec , les questions en tètes et j'ai trouver mon erreur .

Ma mauvaise "Logique" était :

-Tant que ... réponse est oui ---> while(..)
-Faire les fonctions .... --->do.

hors c'est un Do{...}While(...) .
Logique plus claire et totalement ..... logique!!

j'ai beaucoup rester bloquer sur la vérification du "count!=0" et du tant que "count!=0" qui est en suivant d’après l'algorithme.
j'ai eu un autre exercice demandant a faire une comparaison et définir l'affichage en condition,

et j'ai encodé très simplement sans problème.

J'ai du mal avec le While, do..while, for et autre sur le principe d'encoder se qu'il faut faire si la condition est fausse.

ex: avec If (si) ....(condition vrais)
sinon .... (condition fausse)

mais avec while , y pas ce élément ....visuel (si je peux dire).

Donc j'ai remanié le code comme vous me l'avez si bien ré-affiché un peu plus haut,

et ca marche a 99%. :roll::roll::roll:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 #include <iostream> #include <string> int main() { std::string reponse; do { char c; int count=5; while(count != 0) { std::cout << " Saisir une lettre : "; std::cin >> c; if(c == 'k') { std::cout << "gagne" << std::endl; std::cout << "recommencer ?" << std::endl; std::cin >> reponse; } else if( c >= 'k') { std::cout << "en dessous" <<std::endl; count = count - 1; } else { std::cout << "au dessus" <<std::endl; count = count - 1; } } std::cout << "perdu" << std::endl; std::cout << "recommencer ?" <<std::endl; std::cin >> reponse; }while(reponse == "oui"); return 0 ; }
Mon 1% de problème , est quand cas de réponse "oui" , après avoir "Gagner" est qu'il ne réinitialise pas le "count" a 5
et affiche perdu a défaut des 5 tests effectuer(logique).

Mais pas de réponse cette fois , j'aimerais la corriger directement avant .

Je reviendrai quand j'aurai corriger.

Merci quand même, et profiter bien de ce dimanche grisonnant......

Bon, on va donc reprendre la manière de fonctionner de l'ordinateur face à des conditions ;)

Le cas le plus simple : un test (dit "vrai / faux"):
Code:

1 2 3 4 if(condition){ si la condition est vraie, on passe ici } quel que soit le résultat, on continue ici
un cas un peu plus complexe : "quelque chose à faire" si la condition est vraie, "autre chose à faire" si la condition est fausse:
Code:

1 2 3 4 5 6 if(condition){ ce qu'il faut faire si la condition est vraie }else{ ce qu'il faut faire si la condition est fausse } quel que soit le résultat, on continue ici
Les boucle "tant que":
Code:

1 2 3 4 while(condtion){ Tant que la condition est vraie, on exécute ce qui se trouve ici } quand la condition devient fausse, on continue ici
Les conditions " jusque" sont un peu plus complexes encore, car on exécute "quelque chose" avant de vérifier la condition:
Code:

1 2 3 4 5 do{ quelque chose qui sera répété aussi longtemps que la condition sera vraie }while(condition) -->si la condition est vraie, on retourne au niveau du do quand la condition est fausse, on continue ici
Une fois que l'on a compris ce mode de fonctionnement, cela parait tout ce qu'il y a de plus logique, au point que l'on en oublie rapidement qu'on a peut-être eu du mal à comprendre ;)

Citation:

Mon 1% de problème , est quand cas de réponse "oui" , après avoir "Gagner" est qu'il ne réinitialise pas le "count" a 5
et affiche perdu a défaut des 5 tests effectuer(logique).

Héhé... Dis moi, quelle est la condition qui force le programme à retourner dans la boucle lors de l'instruction while(count != 0):question:
Mettons que l'utilisateur trouve la solution dés son premier essais, que vaudra count après cet essais :question: Que va-t-il se passer à ce moment là :question:

EDIT :
Pour information, il est possible de combiner deux (ou plusieurs) conditions de deux manière différentes, dont les noms "plus ou moins barbares" ont été choisis par un certain monsieur boole :

la conjonction, dont le résultat final donne "vrai" si les toutes les conditions sont vraies, et s'exprime sous la forme d'un ET (AND en anglais)
la disjonction, dont le résultat final donne "vrai" si une des conditions (n'importe laquelle) est vraie et s'exprime sous la forme d'un OU (OR en anglais)

En C++, on dispose d'une variante "optimisée" (*) de ces deux relations que l'on représente avec l'opérateur && pour le ET et avec l'opérateur || pour le OU, par exemple:
Code:

1 2 3 4 5 6 7 if(condtion1 && condition2){ ce qu'il faut faire si condtiion1 ET condition2 sont toutes les deux vraies EN MÊME TEMPS } if(condition3 || condition4){ ce qu'il faut faire si condition3 OU condition4 (ou les deux) est / sont vraies }
(*) on dit que ces variantes sont "optimisée" parce que la condition de droite ne sera évaluée que si elle peut encore changer le résultat final. Il existe une variante "logique", dont on parlera peut-être dans une autre discussion ;)

Bien sur, on peut multiplier les conditions "à l'envi", et on peut même mélanger les ET et les OU, mais il faudra faire attention aux règles de priorités, que je t'expliquerai si tu le demande ;) .

Toujours est-il que ces deux opérateurs &&et|| permettent de créer des conditions particulièrement "complexes", ce qui pourrait nous aider énormément dans le cas présent ;)

06/09/2019, 20h11
mikelan

Bonjour ,Koala01,

Travail corrigé et fonctionnel, simple oublie de rénitialisation du"count" apres avoir "gagne".
Encore une fois de la simple logique pur.

Maintenant , mes nouveaux cours recus, on s'oriente vers les traitements factorielles et les pointeurs.. mmmm
on verra .... a l'avenir.

Je tenais a vous remercier encore une fois pour l'aide recue jusqu'a maintenant et .... au

(((( ....::: MERCI :::.... ))))