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.

[Médinoc]

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

[Jean-Marc.Bourguet]

Revoir aussi comment les classes de bases virtuelles sont initialisees.

[vandamme]

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.

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

[Cheps]

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.

[3DArchi]

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 . C'est aussi dans l'idée de prendre des réflexes qui facilitent la vie en développement, en test et en maintenance.

[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(...);
}