Discussion :

[vandamme]

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 :

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

[JolyLoic]

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

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
class Abstract
{
  public:
   Abstract(...) { ... }
   Abstract(ParamPourW p, ...) : w(p) {...}
 
  protected:
   Widget w;
};
 
class Concret : public Abstract
{
  public:
   Concret() : Abstract(p, ...) { ... }
 
};

[Cheps]

Tu pourrais aussi utiliser un pointeur, que tu initialises dans la classe fille.

[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.

[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.

[3DArchi]

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.

[Mat007]

Salut,

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

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

[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.

[3DArchi]

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

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

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

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