Discussion :

[grobs]

Bonjour tout le monnnnnnnde !!

Ma question porte aujourd'hui sur les cast et les types des classes.

J'aimerai réduire ce code pas très joli en une seule instruction plus élégante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Valeur* valeur = 0;
 
if (typeid(*og)==typeid(ValeurEntiere)) {
	valeur = new ValeurEntiere( ((ValeurEntiere *)og)->getValeur() + ((ValeurEntiere *)od)->getValeur());
}
else if (typeid(*og)==typeid(ValeurReelle)) {
	valeur = new ValeurReelle( ((ValeurReelle *)og)->getValeur() + ((ValeurReelle *)od)->getValeur());
}
else { //cest une chaine
	valeur = new ValeurChaine( ((ValeurChaine *)og)->getValeur() + ((ValeurChaine *)od)->getValeur());
}

Il faut savoir que ValeurEntiere, ValeurReelle et ValeurChaine héritent de Valeur

J'ai pensé créer une méthode polymorphe dans chacune de ces classes ou redéfinition de l'opérateur "+".
Avez-vous une manière élégante de faire ceci ?

Merci d'avance !

[Davidbrcz]

En utilisant les template plutôt que le polymorphisme ?
Exemple:

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
37
38
39
 
#include <iostream>
#include <string>
 
template <class T> class Valeur;
template <class T> Valeur<T> operator+(const Valeur<T>& v1,const Valeur<T>& v2);
template <class T> std::ostream& operator<<(std::ostream& flx, const Valeur<T>& v1);
 
template <class T> class Valeur
{
    T val;
 
    friend Valeur<T> operator+ <>(const Valeur<T>& v1,const Valeur<T>& v2); 
    friend std::ostream& operator<< <>(std::ostream& flx, const Valeur<T>& v1);
public:
    operator T() const {return val;}
    Valeur(T t):val(t){}
    T valeur() const {return val;}
};
template <class T> std::ostream& operator<<(std::ostream& flx, const Valeur<T>& v1)
{
    flx<<v1.val;
    return flx;
}
template <class T> Valeur<T> operator+(const Valeur<T>& v1,const Valeur<T>& v2)
{
    return Valeur<T>(v1.val+v2.val);
}
 
int main()
{
    Valeur<int> v1(1),v2(2);
    std::cout<<v1+v2<<std::endl;
 
    Valeur<std::string> s1("Hello "),s2("wolrd");
    std::cout<<s1+s2<<std::endl;
 
return 0;
}

[Jan Rendek]

De ce que je vois de votre code, vous ne voulez pas "ajouter des torchons aux serviettes". Une ValeurEntiere ne peut être ajoutée qu'à une ValeurEntière, une ValeurReelle ne peut être ajoutée qu'à une ValeurReelle, etc...

Cela jette un doute sur la pertinence d'avoir une méthode qui ajoute une Valeur à une Valeur dans la classe de base.

Que souhaitez-vous faire exactement ?