Petit exercice de transformation de type

Version imprimable

16/08/2013, 17h26
Caxton

Petit exercice de transformation de type
Bonjour,

Je pense que c'est le moment pour moi de faire quelques exercice. Je m'était penché sur l'idée de travaillé sur l'héritage. J'ai vue déjà pas mal de choses et ça fonctionne.

J'ai maintenant plus qu'un seul souci à régler et je pense que j'ai du raté quelque chose. J'ai pour habitude; certainement pas la meilleure des habitudes; de couplée texte et chiffre tel que:
Code:

1 2 3 int truc = 2; std::string machin = "truc" + truc + "\n";
En théorie seulement, ça devrais marché. Un string sachant afficher en théorie du chiffre.

En pratique, si ça arrive à passer, c'est devenu des lettres, et dans les 3/4 du temps j'ai des messages d'erreurs liée à char[]. En d'autres terme, suite à mon analyse, je me retrouve donc avec un std::string ne savant que travaillé sous char...

Me voila dans l’embarras !

Sans entrée dans une quelconque classe. Je pense déjà résoudre une partie du problème dans le main seul tel que:
Code:

1 2 3 4 5 int truc = 2; stdstring conf = truc.str(); std::string machin = "truc" + conf + "\n";
D'une je ne suis pas certain que .str() soit la bonne solution.
De deux, il n'est pas prouvé que ça soit la bonne logique.
De trois, j'ai essayer de remplacer les + par <<. Le résultat est guère mieux !

Je propose donc de faire l'étude de ce cas précis. En fonction du résultat et des expérimentation, je pense re écrire ma classe b hérité de a ou un membre de a, donc de b en héritge va afficher les infos au travers de l'interface a. Mais là, c'est une autre blague.

Merci pour votre aide. :ccool:
16/08/2013, 20h13
David Fleury
Je ne suis pas sûr d'avoir compris la question mais peut être std::ostringstream dans <sstream> ?
Code:

1 2 3 4 5 std::ostringstream oss; oss << "truc" << truc << std::endl; std::string str = oss.str();
16/08/2013, 20h53
Arzar
Citation:
Envoyé par Caxton

Code:

1 2 3 int truc = 2; std::string machin = "truc" + truc + "\n";

En théorie seulement, ça devrais marché. Un string sachant afficher en théorie du chiffre.
Euu non il n'y a aucune raison que ça marche même "en théorie". Les seules choses convertibles en std::string en C++ sont les char* comme par exemple "truc" ou les char comme par exemple 'a'.

Pour convertir un int en string tu peux utiliser stringstream, comme montré plus haut, ou encore std::to_string (qui sait convertir en gros entiers et flottants) :
Code:

1 2 int truc = 2; std::string machin = "truc" + std::to_string(truc) + "\n";

Bon, je viens d'essayer !

Alors, voila ce qui se passe; ça compile, mais, si j'en crois la sortie écran, ça n'affiche rien !

Donc à ce stade, je propose de vous montrer mon exercice dans son ensemble. Histoire de rectifier ce qui semble pas correct.

Comme je disait, j'ai deux classes. L'une affiche en solitaire habituellement. L'autre est une extension (c'étais le terme java que j'utilisais) et qui devrait donc s'appuyer sur la première pour afficher les résultat.

La première classe est une classe qui s'appuie sur std::string; la seconde sur des int. Il faudra à u moment donné passé de l'intéger vers du string. C'est ce que semble faire le code indiqué au dessus.

Voila donc, sans plus attendre mon main:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <iostream> using namespace std; #include "message.h" #include "calcul.h" int main() { int t1 = 10; int t2 = 20; calcul calc; calc.setAdd(t1, t2); //cout << calc.res(); return 0; }
Ensuite, je fais venir la première classe. Celle qui affiche avec son .h suivi de son.cpp:
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 #ifndef MESSAGE_H #define MESSAGE_H #include <iostream> using namespace std; class message { public: message(); void setType(std::string t = "NULL") { m_type = t; } void setMessage(std::string m = "") { m_message = m;} std::string send(); private: std::string m_type; std::string m_message; }; #endif // MESSAGE_H #include "message.h" #include <iostream> using namespace std; message::message() { } std::string message::send() { if((m_type == "NULL") || (m_message == "")) { m_type = "ERREUR"; m_message = "ERREUR : Soit le type est manquant, soit le message est manquant !"; } return m_type + "\n" + m_message + "\n"; }
Et enfin la classe qui hérite de la première:
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 #ifndef CALCUL_H #define CALCUL_H #include "message.h" class calcul : public message { public: calcul(); void setAdd(int terme1 = 1, int terme2 = 1); int res(); private: int m_terme1; int m_terme2; int resultat; }; #endif // CALCUL_H #include "calcul.h" #include <sstream> calcul::calcul() { } void calcul::setAdd(int terme1, int terme2) { m_terme1 = terme1; m_terme2 = terme2; resultat = terme1 + terme2; std::ostringstream oss1; oss1 << "Addition pour " << terme1 << " + " << terme2 << " =" << std::endl; std::ostringstream oss2; oss2 << resultat << std::endl; setType(oss1.str()); setMessage(oss2.str()); send(); } int calcul::res() { return resultat; }
Je reconnais que c'est pas un programme très propre dans la mesure ou c'est un exercice. J'y ai tester beaucoup de choses et, par voie de conséquence, il a beaucoup évoluer.

Sachez qu'a la fin, je devrais quand même créer dans la classe enfant, calcul, une méthode qui effectuera le calcul en private, et une méthode qui devra envoyer vers la classe 1 affin d'afficher.

J'aimerais pousser un peu le concept de l'héritage. Pour comprendre son fonctionnement et, en plus pour m'appuyer sur cet exemple pour développer plus tard d'autres programmes. :ccool:

En attendant, je me suis bien amuser dans cette exemple, moi le novice, pour essayer de comprendre comment cela fonctionnais :mrgreen:

Sur ce, je vous tire ma révérence.

Plop !

Rofl, la flemme de faire un edit !

Alors en fait, je faisait une bêtise :mrgreen: Je n'affichais rien !

J'ai modifier mon main ainsi :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
#include <iostream>
 
using namespace std;
 
#include "message.h"
#include "calcul.h"
 
//#include <sstream>
 
int main()
{
    int t1 = 10;
    int t2 = 20;
 
    calcul calc;
    calc.setAdd(t1, t2);
    cout << calc.send();
 
    //cout << calc.res();
 
    return 0;
}

Et mon calcul.cpp comme cela :

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
 
#include "calcul.h"
 
#include <sstream>
 
calcul::calcul()
{
}
 
void calcul::setAdd(int terme1, int terme2)
{
    m_terme1 = terme1;
    m_terme2 = terme2;
    resultat = terme1 + terme2;
 
    std::ostringstream oss1;
    oss1 << "Addition pour " << terme1 << " + " << terme2 << " =" << std::endl;
    std::ostringstream oss2;
    oss2 << resultat << std::endl;
 
    setType(oss1.str());
    setMessage(oss2.str());
}
 
int calcul::res()
{
    return resultat;
}

Devinez quoi ?

Ca marche ! ça marche ! :pc:

16/08/2013, 21h42
Arzar

ARf j'étais en train de taper une réponse comme quoi le seul std::cout du code était commenté et que la string retournée par send() n'était pas utilisée, mais tu as été plus rapide :ccool:
17/08/2013, 08h42
Neckara

Bonjour,

Citation:

Envoyé par Arzar

Euu non il n'y a aucune raison que ça marche même "en théorie". Les seules choses convertibles en std::string en C++ sont les char* comme par exemple "truc" ou les char comme par exemple 'a'.

Ce n'est pas totalement vrai.
Une classe peut implémenter une méthode de conversion explicite ou implicite vers std::string. On peut avoir jusqu'à trois conversions si je ne me trompe pas pour la résolution des surcharges d'une méthode.

Quand on utilise un entier, ce dernier est juste convertit en char. Il est donc bien convertit mais pas de la manière qu'on souhaite.