switch case entrée

Version imprimable

Voir 40 message(s) de cette discussion en une page

switch case entrée

bonjour à tous,
Code:

1 2 3 4 5 6 7 8 9 10 11 //---extrait de fichier!! (..) char choix; switch (choix) { case 's': {cout << "sortie"<< endl;} case 'entrée': {cout << "suite des opérations"<< endl;} (...) //----fin de l'extrait!!
Que mettre à la place de entrée entre les ' ' pour que la touche entrée permette de continuer le programme?
merci de la part d'un débutant en C++
:calim2:

28/03/2011, 11h20
ram-0000

A tester mais '\r' ou '\n' me paraissent des bons candidats

\r est représente le retour chariot et \n représente le saut saut de ligne (ou l'inverse)
28/03/2011, 11h27
senvedgi

switch case entrée

merci pour cette promptitude.
J'avais essayé avant de poster mais cela ne marche pas!
Je suis sur Dev C++ est-ce la raison?
28/03/2011, 11h32
ram-0000
Citation:

Envoyé par senvedgi

Je suis sur Dev C++ est-ce la raison?

Je ne pense pas

Ce que tu peux faire, dans ce cas, c'est afficher la valeur du code e entrée (dans un default)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 (...) char choix; switch (choix) { case 's': {cout << "sortie"<< endl;break;} //case 'entrée': default: { cout << "suite des opérations : " << choix << endl; break; } (...)
//----fin de l'extrait!!

et après, une fois que tu as la valeur, tu remodifies ton code avec cette valeur

[EDIT] Ne pas oublier le break dans les case/default sinon, comportement "surprenant"

j'augmente mon extrait et ajoute la bonne idée de faire sortir la valeur d'entrée de choix après default.
Malheusement la valeur choix entre les deux points ne retourne rien avec <E>(entrée) avec ou sans break.Elle retourne une lettre quelconque tapée à la place de s.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
(...)
char choix;
cout << "<E>/suite ou (s)ortie" << endl;
cin >> choix;
switch (choix)
{
case 's':
{cout << "sortie" << endl ;                                   //ici pas de break
      c=getchar();
      goto icifin;}
//case 'entrée':
default:
        {
        cout << "suite op." << choix <<"."<< endl ;
        break;                                                      //ici break marche
        }     
}

:calim2::cry:

29/03/2011, 21h59
senvedgi

bonsoir,
Merci.Dans mon cas char suffit parce que je ne cherche qu'à utiliser qu'une touche contenant un caractère mais apparemment <enter> en contient 2:\r!!).
Je me suis résolu à utiliser la touche <c>ontinuer à la place de <enter> et la touche <s>ortie pour sortir..
Mais je note string à la place de char pour ailleurs.:ccool:
Cordialement.
31/03/2011, 12h37
oxyde356

Si tu fais un c = getchar(); au lieu de ton cin >> c; au début puis après un case '\n': tu peux handler ton event "touche entrée appuyée". En fait ton problème vient du fait que le délimiteur de chaine de l'objet cin est forcé sur saut à la ligne. Du coup il ne le prend pas comme un caractère mais comme un délimiteur.
31/03/2011, 13h00
senvedgi

je ne pige pas trop..
J'utilise char c;
c=getchar();
comme point d'arrêt standard universel.Si nécessaire je peux mettre x...
voilà la partie qui marche avec (c)ontinuer et (s)ortie
que je voudrais modifier en <E>continuer et (s)ortie

//_________________
1.char choix;
2.//cout << " (c)ontinuer ou (s)ortir"<< endl;
3.cout << " <E>/continuer ou (s)ortir"<< endl;
4.cin >> choix;//CE CIN EST A MODIFIER?CELA NE ME SEMBLE PAS "logique"
5.switch (choix)
6. {
7.//case 'c':
8. case '\n' ou '\r'://QUI SEMBLENT ETRE LE "CODE" de ENTER
9. {goto icimo;}
10. case 's':
11. {
12. //cout << "sortie"<< endl;
13. char c;
14. goto icifin;
15. }
16. }
17.//________________
où mettre quoi?
:calim2:
31/03/2011, 14h00
oxyde356

Pourquoi changer le cin ne te paraît pas logique ?
C'est pourtant bien ce qu'il faut faire.

j'ai donc cru comprendre qu'il fallait modifier les lignes *
(..)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 icimo: * //char choix; //cout << " (c)ontinuer ou (s)ortir"<< endl; cout << " <E>/continuer ou (s)ortir"<< endl; *cin >> c;//hoix; *choix=getchar(); *switch (c)//hoix) { case '\r'://ou '\n' {goto icimo;} case 's': { char c; c=getchar(); goto icifin; } } //________________ icifin: (...)
si on initialise cin avec touche c on peut utiliser ensuite la touche enter comme je le voudrais mais il faut utiliser "c" au départ...C'est un début.Merci.
si------------------------------on ne peut plus sortir avec "s"...
j'ai essayé beaucoup de combinaisons pour me sortir de ce problème sans résultats.

ne pas oublier que le suis débutant de chez débutant.
:calim2::calim2:

31/03/2011, 15h34
oxyde356

Oula oula c'est pas clair du tout là, mais ton dernier code sans tout ce que tu es censé enlever. Et met le avec la balise code, sans oublier de bien l'indenter.

ce soir je simplifie:j'avais conservé le prg d'origine pour apprécier la différence
:P
20h30:
ré-écriture mais je pense que l'indentation ne fonctionnera pas
car il y a une histoire de balise-code à utiliser
si çà marche:P
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 (..) icimo: cout << " <E>/continuer ou (s)ortir"<< endl; *cin >> c; *choix=getchar(); *switch (c) { case '\r'://ou '\n' { goto icimo; } case 's': { char c; c=getchar(); goto icifin; } } //________________ icifin: (...)
:
mais je reste :calim2::calim2:

01/04/2011, 08h14
koala01

Salut,

Tu devrais, surtout, essayer d'éviter les goto, car, à trop les utiliser, tu va te retrouver avec un code "spagetti" particulièrement difficile à relire :P

N'oublie en effet jamais qu'un code est beaucoup plus souvent lu (y compris par toi-même) qu'il n'est compilé et que, bien que ton code puisse te sembler particulièrement clair au moment où tu l'écris, il risque de te sembler beaucoup plus nébuleux dans un mois ou deux (voire moins), quand tu devra revenir dessus :P

En utilisant les différents types de tests et / ou de boucle, et en les combinant avec les retours d'erreur et / ou les exceptions, il est tout à fait possible de s'en passer, et donc de rendre le code beaucoup plus lisible.
01/04/2011, 09h46
oxyde356

Pourquoi il y a des étoiles et des lignes inutiles. Ne met que ce que tu as dans ton code. Le cin >> c; il faut le virer et mettre un c=getchar(); a la place du choix=getchar(); Après tu fais un switch sur "c" et tu fais un case '\n': et après je ne vois même pas pourquoi tu refais un c=getchar() dans un case.

réponses:
1)les * c'est pour montrer les modifs seulement.Il faut les enlever pour tester évidemment.
2)les goto c'est parce que j'ai 3 boucles imbriquées en while et que je n'arrive pas à sortir (icifin) ni à reprendre le calcul (icimo)
3)si j'utilise des getchar() c'est pour suspendre les calculs momentanément
4)Mais le plus maintenant c'est que ce que cherche à faire <E> pour continuer avec <Enter> et <s> pour sortir définitivement fonctionne.:ccool:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 (..) icimo: cout << " <E>/continuer ou (s)ortir"<< endl; c=getchar(); switch (c) { case '\n': { goto icimo; } case 's': { char c; goto icifin; } } //________________ icifin: (...)
Il me reste à remercier oxyde pour son action décisive
et koala pour sa stratégie technique car j'ai ontenu ce que je voulais.Merci à tous!
Sen.:lahola::arf:

Ah ok c'est tout bon alors ^^ bon par contre je vais te reprendre un peu ton code parce que il faut que tu élimine tes goto.

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
(...)
bool exit = false;
while(!exit)
{
    cout << " <E>/continuer ou (s)ortir"<< endl;
    char c = getchar();
    switch(c)
    {
            case '\n':
            {
                // action continuer
                break;
            } 
            case 's':
            {
                // action sortie
                exit = true;
                break;
            }
            default:
            {
                // action par défaut
                cout << "erreur symbole non reconnu" << endl;
                break;
            }
    } 
}
(...)

Voilà, c'est beaucoup plus rigoureux, pose des questions si tu ne comprend pas. Dans tous les cas évite les goto, il ne faut jamais les utiliser.

généralement je rédige mes messages en plusieurs fois:attendre qq minutes!
avec mes excuses car je m'apperçois que je n'utilisais pas des boucles while
mais des do/while.:cry:

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
 
(..)//il y a 2 autres do/while au dessus!!!!
do//js
              {//js 
              ijs++;        
              js++;
                  if (js>mjs)
                  {
                  (js = 1);
                  }      
                  if (ijs >mjs )
                  {
                  (ijs = 1);
                  }
                            cout <<"Lec. s:"<< js <<" q:"<<qa<<" m:"<< mo;
                            cout << " <E>/continuer ou (s)ortir"<< endl;
                            c=getchar();
                            switch (c)
                            {
                            case '\r':
                            {goto icimo;}     
                            case 's':
                            {char c;
                            goto icifin;}
                   }      
               }//js          
while (ijs < mjs );

:oops:

01/04/2011, 12h20
oxyde356

Ah mais ça marche aussi parfaitement dans ce contexte là donc ça va ! mais c'est juste que dans le code que tu nous as montré il n'y en avait pas alors qu'il y aurait du y en avoir.
04/04/2011, 08h35
senvedgi

Dès avant lecture cela ne marchera pas parce qu'il y a un break qui renvoie en bas alors que le {goto icimo},que j'aurais dû appeller icihaut, supprimé par un break renvoie en haut de la boucle.Je vais essayer de ré-écrire pour que les 3 boucles soient plus normales aller du haut en bas.
Précision:le programme comporte 3 boucles emboitées qui tournent les unes après les autres,les variables de chaque boucle sont incrémentées à chaque tour.La sortie finale est destinée à sortir de la boucle externe {goto icifin}.
Dimanche j'ai essayé cela ne marche pas à cause du break sous '\n' ou '\r'.
Je tiens au courant pour la modif des boucles.

Ce qu'il est surtout important de comprendre, c'est que l'un des grands principes de la programmation structurée est la "délégation des tâches et des responsabilités".

Nous pouvons en effet dire que, si une fonction fait plus d'une chose, a plus d'une responsabilité, c'est qu'elle en fait trop, qu'elle a trop de responsabilités.

En langage courent, nous dirions "diviser pour mieux régner" :D

Le code que tu présentes est l'exemple type de ce qu'il faut éviter par dessus tout, car, de toute évidence, chaque boucle représente une responsabilité particulière.

ainsi, la boucle la plus imbriquée (celle qui présente le menu) devrait se faire dans une fonction dédiée qui... présenterait le menu et gérerait la réponse de l'utilisateur.

Cette fonction pourrait prendre la forme de
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 /** @brief a function that asks to the user if he want to continue or not * * this function will enter in a loop until user's choice is coherent with * what is expected * * @params : none required * @return : true if the user want to continue, false otherwhise */ bool menuContinue() { do { std::cout<<"voulez vous continuer ? \n" <<" <E>ncore <S>ortir"<<std::endl; char c = getchar(); /* on accepte E et e pour encore */ case 'E' : case 'e' : return true; /* et on accepte s et S pour sortir */ case 'S' : case 's' : return false; /* si ce n'est ni l'un ni l'autre, on rappelle à l'utilisateur ce * que l'on attend */ default : std::cout<<"Veuillez choisir uniquement 'E' ou 'S'"<<std::endl; } while(true); /* on entre dans une boucle infinie... la sortie se fera * lorsque l'utilisateur aura donné un des choix autorisés */ /* on ne passera jamais ici, mais cela nous permet d'éviter un * avertissement de la part du compilateur */ return false; }
Cette fonction pourrait être applée à la fin d'une boucle dans une autre fonction proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 /** @brief a complex stuff who need a before execute menu, an init function, * a compute function and a finalize function * * each of them will give a part of the complex stuff */ bool complexStuff(/* params if needed */) { bool again; do { Type begin= firstMenu(); /*a menu for the begining (1)*/ OtherType init = initialize(begin); // function wich initialize the stuff (2) FinalType final = compute(init); // computing the initialized datas (3) finalize(final) ; // finalization for computed datas (4) again = menu() ; // ask to the user if he wants to continue } while (again); return otherMenu(); // will decide if calling function will enter again // in its own loop (5) }
où
firstMenu est une fonction (comprenant éventuellement une boucle permettant de s'assurer de la pertinence de la réponse donnée par l'utilisateur) qui permettra de récupérer les informations à traiter (par exemple)
initialize est une fonction permettant d'initialiser les données à des valeurs cohérentes, peut etre en boucle, et faisant peut être elle-même appel à des fonctions plus particulières
compute étant une fonction permettant de travailler sur les données récupérées, sans doute grace à une boucle, voire à d'autres fonctions plus spécialisées
finalize est une fonction permettant la gestion finale du résultat, éventuellement en boucle et / ou faisant appel à d'autres fonctions plus spécialisées
otherMenu est une fonction permettant d'offrir d'autres choix à l'utilisateur, fonctionnant peut etre en boucle (pour s'assurer de la pertinence des réponses de l'utilisateur), et faisant peut être appel à des sous fonctions spécialisées

Cette fonction (complexStuff) pourrait, elle-même, etre utilisée en boucle par une autre fonction (moreComplexStuff) proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 void moreComplexStuff(/* params, if needed */) { maybeSomethingBeforeLoop(); // tout ce qui devrait etre fait avant la // boucle bool again; do { maybeInLoopBeforeStuff(); // ce qui doit etre fait en boucle, mais // AVANT ce qui est exécuté par complexStuff again =completeStuff(/* needed params */); //nos boucles imbriquées maybeInLoopBeforStuff(); // ce qui doit etre fait en boucle, mais // APRES ce qui est exécuté par complexStuff }while(again); maybeSomethingAfterLoop(); // tout ce qui devrait etre fait avant la // boucle }
qui pourrait parfaitement être appleée par ...(on pourrait continuer longtemps comme cela :D).

au final, tu pourrais avoir une fonction main qui prendrait la forme (un peu excessive, sans doute) de
Code:

1 2 3 4 5 6 7 8 int main( int argc, char *argv[]) //uniquement si nécessaire { computeArguments(argc, argv); //uniquement si nécessaire initApplication(); moreComplexStuff(); finalizeApplication(); return ; }

Voir 40 message(s) de cette discussion en une page