Discussion :

[sinasquax]

Bonjour a tous, j'ai un petit probleme :

J'ai une classe CMere par exemple et une classe CFille dérivée de CMere, ma classe CFille contient des méthodes virtuelles de CMere mais aussi des méthodes qui lui sont propres.

J'ai ensuite une liste (dans une autre classe ou fonction, peu importe) de pointeurs de CMere où je peux mettre des CMere ou des CFille.

Mon probleme est que selon le type (CMere ou CFille), j'appelerai telle ou telle méthodes.

J'ai donc utilisé un enum EType dans la classe de base (CMere) avec tout les types de filles possibles et un constructeur qui demande un type en parametre.

Les classes filles vont utiliser ce constructeur pour specifier leur type et une methode getType dans la classe CMere permet de savoir le type de la classe.

Mais cette méthode ne me plait pas trop car il faut chaque fois modifier la classe de base (rajouter un type dans l'enum) si on doit rajouter une classe fille et je pense que ca reflete une mauvaise conception.

Je viens de voir qu'il y avait moyen de le faire avec le RTTI et les typeid ou les dynamic_cast pour connaitre le type des classes mais il parait que c'est lourd a gérer point de vue performance.

Donc ma question est de savoir si ma méthode etait bonne, ou bien si le RTTI etait mieux ou bien si finalement c'est une mauvaise conception des classes.

Car je me dis qu'en fin de compte le meilleur est d'avoir la classe de base qui contient toute les méthodes virtuelles possible des classes filles ainsi plus besoin de connaitre le type, il suffit d'appeler la méthode virtuelle qu'on a besoin mais le probleme c'est que mes classes filles sont forts differentes et donc la classe mere serait trop "grosse" et aussi si je devrai ajouter une classe fille je devrai quand meme modifier la classe mere.

Merci

[Davidbrcz]

Ce que tu demande relève surtout un problème de conception.
Dit nous plutôt ce que tu souhaite faire pour qu'on puisse réelement t'aider.

[sinasquax]

Ok donc ma classe de base est CValue :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 class CValue
 {
  public :
 
   // *** METHODS ***
 
   CValue () {}
   virtual ~CValue () {}
 
   virtual const std::string toString (void) = 0;
 };

Et des classes filles, j'en met 3 mais il y en a plus :

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
 
 class CValueInteger : public CValue
 {
  public :
 
   // *** METHODS ***
 
   CValueInteger () : m_value(0) {}
   CValueInteger (const int &value) : m_value(value) {}
   //virtual ~CValueInteger ()
 
   const int &getValue (void) { return m_value; }
 
   void setValue (const int &value) { m_value = value; }
 
   virtual const std::string toString (void);
 
  private :
 
   // *** MEMBERS ***
 
   int m_value;
 };

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
 
 class CValueNumber : public CValue
 {
  public :
 
   // *** METHODS ***
 
   CValueNumber () : m_value(0) {}
   CValueNumber (const double &value) : m_value(value) {}
   //virtual ~CValueNumber ()
 
   const double &getValue (void) { return m_value; }
 
   void setValue (const double &value) { m_value = value; }
 
   virtual const std::string toString (void);
 
  private :
 
   // *** MEMBERS ***
 
   double m_value;
 };

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
40
41
 
 class CValueLength : public CValueNumber
 {
  public :
 
   // *** CONSTANTS ***
 
   static const char *MetricSystemName[];
 
   // *** ENUMS ***
 
   enum EMetricSystem
   {
    EM = 0,
    EX,
    PX,
    IN,
    CM,
    MM,
    PT,
    PC
   };
 
   // *** METHODS ***
 
   CValueLength () : CValueNumber(0), m_metricSystem(PX) {}
   CValueLength (const double &value, const EMetricSystem &metricSystem) : CValueNumber(value), m_metricSystem(metricSystem) {}
   //virtual ~CValueLength ()
 
   const EMetricSystem &getValue (void) { return m_metricSystem; }
 
   void setValue (const EMetricSystem &metricSystem) { m_metricSystem = metricSystem; }
 
   virtual const std::string toString (void);
 
  private :
 
   // *** MEMBERS ***
 
   EMetricSystem m_metricSystem;
 };

Ensuite j'ai une liste de pointeurs de CValue :

Code :

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

1
2
3
4
 
typedef std::vector<CValue *> CValues;
 
CValues valueList;

Et j'ajoute des CValue * dans la liste mais ca peut etre un CValueNumber *, un CValueInteger *, ... selon le besoin.

Et plus tard dans le code je parcours cette liste pour afficher des choix a l'utilisateur (pouvoir voir la valeur, la modifier, ...) mais si par exemple je tombe sur un CValueLength l'utilisateur doit pouvoir choisir le systeme metrique, mon probleme est donc de savoir les types de classes dans la liste pour afficher les informations en conséquence.

[loufoque]

Utilise le design pattern Visitor.

[sinasquax]

Utilise le design pattern Visitor.

Merci de ta réponse, je me suis documenté sur les design pattern, donc dans ce cas ma classe visitable serait CValue et ma classe visiteur serait la classe qui gérerait l'affichage des valeurs :

Code :

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

1
2
 
for (CValues::const_iterator it = valueList.begin(); it != valueList.end(); ++it) visiteurAffichage.visite(*it);

Un style a ca ?

[loufoque]

Non. Apparemment tu n'as rien compris à ce qu'était ce design pattern.

Au lieu de faire

Code :

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

1
2
3
4
5
6
7
8
9
if(Type1* v = dynamic_cast<Type1*>(&obj))
{
   ...
}
else if(Type2* v = dynamic_cast<Type2*>(&obj))
{
   ...
}
...

tu fais

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
struct MachinVisitor : Visitor
{
    void operator()(Type1& v) const
    {
         ...
    }
 
    void operator()(Type2& v) const
    {
        ...
    }
 
    ...
};
 
obj.visit(MachinVisitor());