[POO] Conseils sur conception

Version imprimable

Voila, j'ai une classe abstraite qui utilise un objet qui ne peut être initialise que dans des classes concrètes qui vont implémenter cette classe abstraite.
Cela me donne :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class Abstract { public: Abstract(...) { ... } protected: Widget w; }; class Concret : public Abstract { public: Concret() : Abstract(...), w(...) { ... } };
Ce qui me gène c'est que w est initialise une première fois lorsque le ctor de Concret appelle celui de Abstract puis une seconde fois explicitement.
Cette me conception me semble douteuse.
Que préconiserez vous dans un tel cas, ie lorsque j'ai un attribut w dont une classe mère se sert mais qui ne peut être initialise que dans une classe fille concrète ?

Le plus simple qui me vient en tête (sans en savoir plus, dur de réfléchir) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Abstract
{
  public:
   Abstract(...) { ... }
   Abstract(ParamPourW p, ...) : w(p) {...}
 
  protected:
   Widget w;
};
 
class Concret : public Abstract
{
  public:
   Concret() : Abstract(p, ...) { ... }
 
};

17/11/2008, 08h45
Cheps

Tu pourrais aussi utiliser un pointeur, que tu initialises dans la classe fille.
17/11/2008, 09h13
3DArchi

Bonjour,
Tu peux aussi utiliser boost.In place factory ou Boost.Optional pour décaler ton initialisation dans le constructeur de ta classe fille.
17/11/2008, 09h48
vandamme

Oui, c'est pas mal l'idee du pointeur.
La classe mere l'initialise a NULL et ensuite, la vraie init se passe ensuite dans la classe fille.
17/11/2008, 09h58
3DArchi

Citation:

Envoyé par vandamme

Oui, c'est pas mal l'idee du pointeur.
La classe mere l'initialise a NULL et ensuite, la vraie init se passe ensuite dans la classe fille.

Si ce n'est qu'il va te falloir gérer un pointeur avec tout ce que cela suppose.... Je me répète, boost.optional peut être une solution qui ressemble à du pointeur mais avec les soucis en moins.
17/11/2008, 10h17
Médinoc

PS: Les constructeurs de Abstract devraient être protected, tout comme son destructeur s'il n'est pas virtuel.
17/11/2008, 10h58
Jean-Marc.Bourguet

Revoir aussi comment les classes de bases virtuelles sont initialisees.
17/11/2008, 10h59
vandamme

Citation:

Envoyé par Médinoc

PS: Les constructeurs de Abstract devraient être protected, tout comme son destructeur s'il n'est pas virtuel.

Oui, tu as raison, mais un destructeur meme virtuel peut etre protected non ?
Je pensais en fait que lorsqu'on avait une fonction virtuelle pure dans une classe abstraite donc, on ne pouvait pas appeler son ctor meme s'il est public.
17/11/2008, 11h05
Médinoc

Bien sûr qu'on ne peut pas l'appeler même s'il est public, mais je pense que c'est une bonne pratique à prendre, abstraite ou non.

Quant au destructeur, il peut être à la fois protected et virtuel, mais je ne vois pas trop quand c'est nécessaire. GotW conseille soit l'un soit l'autre...
17/11/2008, 12h41
Cheps

Citation:

Envoyé par 3DArchi

Si ce n'est qu'il va te falloir gérer un pointeur avec tout ce que cela suppose.... Je me répète, boost.optional peut être une solution qui ressemble à du pointeur mais avec les soucis en moins.

Dans son cas, avec un membre non accessible de l'extérieur, il suffit de faire un new dans le constructeur et un delete dans le destructeur. Je ne vois aucun problème ici pour un pointeur.
17/11/2008, 12h55
3DArchi

Citation:

Envoyé par Cheps

Dans son cas, avec un membre non accessible de l'extérieur, il suffit de faire un new dans le constructeur et un delete dans le destructeur. Je ne vois aucun problème ici pour un pointeur.

Et gérer la construction par copie et l'affectation. Tiens, c'est déjà un peu plus :D. C'est aussi dans l'idée de prendre des réflexes qui facilitent la vie en développement, en test et en maintenance.

Salut,

Il y a aussi ça comme solution éventuellement possible :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class Abstract { public: Abstract( const Widget& w, ...), w_( w ) { ... } private: Widget w_; }; class Concret : public Abstract { public: Concret() : Abstract( CreateWidget( ... ), ...) { ... } private: static Widget CreateWidget( ... ); };
Ou tant qu'à faire avec une fonction libre dans un namespace anonyme, même.

MAT.

17/11/2008, 14h27
vandamme

Oui, cette derniere reponse me plait bien.
Mais avec le pointeur c pas mal aussi, surtout que ma classe n'a pas besoin d'etre ni copiable ni assignable.
Je peux donc a la rigueur encapsuler le pointeur dans un auto_ptr dans ce cas.

Ca implique que Widget soit constructible par copie.
Une solution avec boost sans pré-supposé sur les classes:

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
#include <boost/optional.hpp>
#include <boost/utility/in_place_factory.hpp>
 
class Widget
{
public:
   Widget(std::string _str)
   {
   }
};
 
class Abstract
{
public:
   template<class InPlaceFactoryT>
   Abstract(InPlaceFactoryT _p):w_(_p){}
protected:
   boost::optional<Widget> w_;
};
class Concret:public Abstract
{
public:
   Concret():Abstract(boost::in_place("tutu")){}
};

Ensuite tu utiliser w_ comme un pointeur:

Code:

1
2
3
4
5
 
Abstract::MaFonction(...){
  (*_w).Fonction1(...);
  _w->Fonction2(...);
}