Discussion :

[senvedgi]

bonjour à tous,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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++

[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)

[senvedgi]

merci pour cette promptitude.
J'avais essayé avant de poster mais cela ne marche pas!
Je suis sur Dev C++ est-ce la raison?

[ram-0000]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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"

[senvedgi]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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
        }     
}

[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.
Cordialement.

[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.

[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?

[oxyde356]

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

[senvedgi]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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.

[senvedgi]

ce soir je simplifie:j'avais conservé le prg d'origine pour apprécier la différence

20h30:
ré-écriture mais je pense que l'indentation ne fonctionnera pas
car il y a une histoire de balise-code à utiliser
si çà marche

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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

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

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.

[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.

[senvedgi]

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.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[oxyde356]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[senvedgi]

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.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 );

[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.

[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.

[koala01]

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"

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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ù

1. 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)
2. 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
3. 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
4. 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
5. 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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ).

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ;
}