Discussion :

[nekcorp]

Bonjour,

soyez indulgent je d�bute en C++ et je suis entrain de m'exercer.

Alors mon exo consiste � demander � l'utilisateur de rentrer ses notes que j'ajoute � un tableau dynamique pour ensuite calculer la moyenne.

L'utilisateur continue de rentrer ses notes tant qu'il ne tape pas le mot fin

Voici mon code pour l'instant :

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
 
 
    vector <double> listeDesNotes;  // On definit un tableau dynamique (vector) vide.
    double moy(0);
    double answer(0);
 
 
    while(answer!="fin"){
        std::cout << "Veuillez entrer vos notes :"<<std::endl;
        cin >> answer;
 
        if(answer=="fin"){
             break;
        }
        else {
            listeDesNotes.push_back(answer);
        }
    }
 
    // Calcul de la moyenne

Mon soucis c'est comment d�finir answer car je ne peux pas lui dire d'�tre � la fois un double et un string.

Merci d'avance pour votre aide.

[Corluk]

Stocke les donn�es en tant que std::string et utilise std::stod apr�s.

Quelques astuces :

• std::cin et std::cout sont li�s, donc std::endl est redondant avant de lire de std::cin. '\n' suffit. Pour la diff�rence entre \n et std::endl, lis cela.
• Je recommande de ne pas utiliser double moy(0) mais double moy = 0 ou double moy{0} � la place. Plus d'information disponible ici sur ce sujet.

[nekcorp]

Merci pour ta r�ponse, j'ai r�gl� mon probl�me.

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
 
   vector <double> listeDesNotes;  // On definit un tableau dynamique (vector) vide.
    double moy(0);
    std::string answer;
 
 
    while(answer!="fin"){
        std::cout << "Veuillez entrer vos notes (tapez fin pour arreter la saisie) :";
        std::cin >> answer;
 
        if(answer=="fin"){
            break;
        }
 
        else {
            listeDesNotes.push_back(std::stod (answer));
        }
    }
 
    // Calcul de la moyenne
 
    moy = calculMoy(listeDesNotes);
 
    std::cout<<"Vous avez obtenu une moyenne de : /20" << moy << std::endl;

[koala01]

Salut,

En fait, tu dois faire la distinction entre l'introduction (par l'�l�ve) de ses notes et la mani�re dont tu veux les maintenir en m�moire, afin de pouvoir les utiliser

Il est, sans doute, "de bon ton" de traiter � la base toutes les entr�es effectu�es par l'utilisateur comme s'il s'agissait de string, parce que leur valeur peut repr�senter � peu pr�s tout et n'importe quoi.

Mais, d'un autre cot�, il serait totalement aberrant d'accepter de la part de l'utilisateur qu'il introduise "quelque chose" qui ne pourrait pas �tre consid�r� comme (mettons la chaine de caract�res "hello world!") une note lorsqu'on s'attend sp�cifiquement � ce qu'il introduise une note.

De m�me, il serait totalement aberrant de maintenir en m�moire "quelque chose" que l'on consid�re explicitement comme une note sous une forme autre que celle d'une donn�e d'un type diff�rent que celui qui nous permet -- effectivement -- de manipuler la note; surtout si ce "quelque chose" ne peut pas �tre consid�r� comme une note valide.

Tu dois donc travailler sans doute en deux temps, � savoir:

1. accepter que l'utilisateur introduise n'importe quoi dans un premier temps puis
2. tenter de convertir ce "n'importe quoi" en une note valide et, en fonction du r�slutat de cette tentative:
   
   • si la conversion r�ussi: c'est tr�s bien, tu peux stocker la note (sous la forme d'un type adapt� aux manipulations que tu en feras) en m�moire ou
   • si la conversion �choue: engueuler l'utilisateur pour le rappeler � l'ordre, et recommencer en (1)

Et ce n'est qu'une fois que cette logique (pas tr�s compliqu�e, somme toutes) sera mise en place que tu pourra envisager de cr�er une boucle pour permettre l'extraction de plusieurs notes d'affil�es

La premi�re �tape peut �tre simple, car il peut suffire d'une fonction (tiens, profitons en pour faire en sorte qu'elle puisse fonctionner pour lire des fichiers, tant qu'on y est) qui prendrait la forme de

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
std::string readInput(std::istream & ifs){
    std::string input;
    std::getline(ifs, input);
    return input;
}

C'est "tout ce qu'il y a de plus simple, n'est-ce pas

Ensuite, nous voudrons sans doute afficher un message � l'utilisateur pour lui dire ce que l'on attend de sa part. Cependant, ce message n'aura aucun sens si la donn�e doit �tre r�cup�r�e depuis un fichier.

Nous pourrions donc cr�er une fonction qui provoque effectivement l'affichage si le message � afficher existe, et qui renvoie le r�sultat de readInput sous une forme proche de

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
std::string maybeAskInput(std::istream & ifs, std::string const & message){
    if(!message.empty())
        std::cout<< message;
    return readInput(ifs);
}

Gr�ce � cela, nous pouvons cr�er une fonction qui s'occupe sp�cifiquement de convertir une chaine de caract�res en note et qui, selon le cas, pourra afficher un message pour engueuler l'utilisateur ou lancer une exception et qui prendrait une forme 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
bool convertToNote(std::string const & value, double & result, bool showError ){
    size_t pos{0}; // la position finale après conversion
    double temp = std::stod(value, & pos);
    /* est-ce que toute la chaine de caractères a été traitée? */
    if(pos== value.size()){ // si oui, on renvoie la valeur récupérée
        result = temp;
        return true;
    }
    /* si on arrive ici, c'est "qu'un problème" est survenu ... */
    // Soit l'utilisateur n'a pas introduit une valeur entière, et on doit donc l'engueuler */
   if(showError){
       std::cout<<"Veuillez introduire une valeur réelle uniquement \n";
    }else{
        /* soit la donnée vient d'ailleurs, et on lance une exception */
        throw std::runtime_error("incompatible data retrieved");
    }
    /* pour le cas où on n'a pas lancé d'exception */
    return false;
}

Maintenant que nous avons tout cela, nous pouvons envisager de cr�er une boucle pour faire bonne mesure. La fonctions que je te propose de cr�er va, encore une fois, permettre l'extraction de donn�es depuis un fichier ou depuis l'introduction de l'utilisateur gr�ce � un simple bool�en, et prendra une forme 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
20
21
22
23
24
25
26
27
28
29
30
31
32
std::vector<double> readNotes(std::istream & ifs, bool showMessage ){
    std::vector<double> notes;
    bool again{true}; // pour savoir s'il faut continuer ou pas
    /* la boucle devra s'effectuer au moins une fois */
    do{
        /* Le message "de base", qui ne demande rien */
        std::string message{""};
        /* si on veut un affichage, le message sera plus complet */
        if(showMessage){
            message.append("Veuillez introduire la note ")
                   .append(std::to_string(notes.size()+1))
                   .append(" (ou \"fin\" pour terminer ");
        }
        auto result = maybeAskInput(ifs, message);
        /* traitons d'office la possibilité que l'on ait obtenu le mot "fin" */
        if(result =="fin"){ 
            again = false;
        }else{ // sinon, on tente la conversion
            double final;
            if(convertToNote(result, note, !message.empty())){
                /* si la conversion réussi, on peut ajouter la note aux 
                 * tableau de résultats
                 */
                notes.push_back(final;
            }
        }
    }while(again);
    /* quand on arrive ici, c'est qu'il est temps de renvoyer les notes
     * obtenues
     */
    return notes;
}

Maintenant, il ne reste plus qu'� fournir la fonction "main" pour mettre tout cela en musique. Si l'on veut que ce soit l'utilisateur qui introduise ses notes, cela pourrait prendre une forme proche de

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
int main(){
    auto result = readNotes(std::cin, true);
    std::cout<<"Vous avez introduit les "<<result.size() <<" notes que voici :\n";
    for(auto it : result)
        std::cout<<it<<"\n";
    return 0;
}

Si on veut extraire les notes d'un fichier (mettons qu'on l'ait appel� data.txt), la fonction main pourrait prendre la forme de

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
int main(){
    std::ifstream ifs("data.txt");
    auto result = readNotes(ifs, false);
    std::cout<<"Le fichier contenait les "<<result.size() <<" notes que voici :\n";
    for(auto it : result)
        std::cout<<it<<"\n";
    return 0;   
}

Et, pour que cet exemple puisse fonctionner, voici un exemple pour le fichier data.txt:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
12
15
13.5
5.5
10.7
19
fin

Au final, le principal enseignement que tu dois tirer de tout cela, c'est que n'importe quel probl�me, aussi complexe soit-il, peut �tre d�compos� en une suite logique d'�tapes plus simples � mettre en oeuvre, et que chacune de ces �tapes m�rite d'�tre impl�ment�e sous la forme d'une fonction qui ne s'occupe que de l'�tape consid�r�e

Alors, bien sur, j'ai abord� une approche "bottom up" ici, en commen�ant par les �tapes les plus simples, avant de m'attaquer aux �tapes les plus complexes.

Ce qu'il y a sans doute int�r�t � faire, c'est de partir d'une approche "top down" pour dresser la liste des diff�rentes �tapes qui seront n�cessaire pour r�soudre le probl�me le plus compexe, avant d'utiliser une approche "bottom up" pour impl�menter ces �tapes