Variable pouvant �tre un double et un string

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:

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.

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.

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

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

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 :aie:

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:
accepter que l'utilisateur introduise n'importe quoi dans un premier temps puis
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:

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 :D

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:

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:

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:

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:

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:

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:

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