Etendre une série de classe non modifiable/ Héritage virtuel

Version imprimable

10/11/2010, 13h03
NoIdea

Etendre une série de classe non modifiable/ Héritage virtuel
Bonjour à tous. J'aimerais connaitre la meilleur façon d'étendre une classe du type :

class Base (classe abstraite);
class Derived1 : public Base;
class Derived2 : public Base;
class Derived3 : public Base;

Le problème étant que j'aimerais créer créer une nouvelle classe, similaire à Base mais possédant une fonction virtuelle pure et définir l'implémentation de cette fonction virtuelle pure dans Derived1, Derived2 et Derived3.

Le problème : je dois créer cette nouvelle classe sans toucher au code de Base, Derived1, Derived2 et Derived3. De plus, il faudrait qu'à chaque extension de Base ma classe s'étende aussi sans y toucher. Et pour finir, il faudrait pouvoir rajouter des classes sans problème.

On pourrait imaginer un :
Code:

1 2 3 4 5 6 7 8 class MonBase : public Base { virtual bool f()=0; }; class MonDerived1 : virtual public MonBase, virtual public Derived1 { virtual bool f(){/*qqch*/} };
....

ce système fonctionnerais.

Cependant, sa me parait mettre beaucoup de code pour pas grand chose et l'héritage virtuelle ne me parait pas super.
Pour la syntaxe du virtuel, je m'en souvient plus très bien (c'est la première fois que cette possibilité est envisageable) mais si c'est la seule solution je ferais comme sa.

Merci.
10/11/2010, 14h49
Steph_ng8

Bonjour,
Je crois que quelques précisions s'imposent, histoire d'être bien sûr qu'on parle de la même chose…

Citation:

Envoyé par NoIdea

j'aimerais créer créer une nouvelle classe, similaire à Base

Qu'est-ce que tu entends exactement par « similaire » ?
En gros, il faut qu'elle ait exactement le même comportement que « Base », quoiqu'il arrive ?

Citation:

Envoyé par NoIdea

De plus, il faudrait qu'à chaque extension de Base ma classe s'étende aussi sans y toucher.

Qu'est-ce que tu veux dire par « extension » ?
Des ajouts dans la classe ?
D'autres classes-filles ?

Citation:

Envoyé par NoIdea

Et pour finir, il faudrait pouvoir rajouter des classes sans problème.

Rajouter des classes…
Euh, où ça ?

Pour l'héritage virtuel, direction la FAQ.
Mais je crains qu'il faille modifier les classes « Derived* ».
10/11/2010, 15h12
NoIdea

Semblerais que je n'ai pas été assez explicite.
Je vais donc prendre le cas qui m'intéresse.
J'utilise la SFML et je ne souhaite pas modifier les sources.
Cependant, dans la classe Drawable, il me manque une méthode cruciale : virtual bool IsOnDrawable()=0;
Cette fonction est virtuelle pure et j'ai déjà prévu quel serait son comportement pour les Shape/Sprite/String.

Mon problème : je ne veux modifier les sources. Je ne peux donc rajouter ces trois fonctions dans les .h correspondants.
Cependant, il me faudrait qu'à chaque nouvelle version de la SFML (imaginons une nouvelle fonction dans la classe Drawable) soit présente dans ma nouvelle classe sans modifier une seule ligne de code.
De plus, on doit pouvoir implémenter les classes Shape/Sprite/String avec cette nouvelle fonction. Il faut donc créer ShapeBis, SpriteBis et StringBis. Malheureusement, il faut aussi que c'est trois classe "se mettent à jour automatiquement" quand Shape, Sprite et String sont modifiés. Ou encore, si il s'agit d'un type qu'une autre bibliothèque a créé (qui hérite de Drawable)et qu'on ne veut aussi modifier.

Ainsi, j'en conclut que DrawableBis doit hériter de Drawable (pour permettre "les mises à jours") ; que toute classe héritant de Drawable à laquelle on veut rajouter cette fonction (appelons la DerivedBis) doit hériter de DrawableBis et de Derived.

Ainsi, j'obtiens un losange et donc un héritage virtuel.

Y a t-il une autre solution ?
10/11/2010, 15h28
AF_2.8

Tu peux envisager d'utiliser des design pattern (le design pattern decorator pourrait répondre à ce que j'ai compris de ton problème.)
10/11/2010, 16h19
Steph_ng8

Ok, je vois.
C'est à peu près ce que j'avais compris, mais je voulais être sûr. ;)

Faire de l'héritage multiple pourrait être une solution (enfin disons plutôt une façon de faire…).
Mais comme je le disais, il faudrait modifier les classes Shape/Sprite/String.
Donc ce n'est pas possible.

Je ne pense pas assez aux design pattern, alors qu'ils peuvent rendre de bien grands services, et parfois de manière assez simple… :)

Il me semble que le pattern Decorator ne répondent pas à mes besoin : il faudrait modifier Drawable (le faire hérité d'une interface). Cependant, je ne le connaissais pas et répond à un autre besoin que j'avais ;)

Je vais essayé de faire un shémas en asseyant d'être plus compréhensible.

Voila les classes SFML, je n'ai le droit de toucher à aucune de ces classes. Il manque une méthode virtuelle pure bool IsOnObject(const Point& P)const dans Drawable et leur implémentation dans les dérivés.
Code:

1 2 3 4 Drawable / | \ Shape Sprite String
Maintenant, voici les nouvelles classes :
Code:

1 2 3 4 DrawableBis / | \ ShapeBis SpriteBis StringBis
Or, DrawableBis doit hérité de Drawable pour avoir toutes les méthodes/propriété de Drawable. On a donc :
Code:

1 2 3 4 5 6 Drawable | D R A W A B L E B I S / | \ ShapeBis SpriteBis StringBis
Or, ShapeBis, SpriteBis et StringBis doivient hériter respectivement de Shape, Sprite et String pour avoir toues leurs méthodes/propriétés.

On obtient donc :
Code:

1 2 3 4 5 6 ---------Drawable--------------------- | | | | D R A W A B L E B I S | | / | \ | ShapeBis SpriteBis StringBis
Il nous faut donc de l'héritage virtuel. Cependant, on arrive au résultat voulu.

Ma question est :

Existe-il une solution sans héritage virtuel ?

10/11/2010, 18h01
3DArchi
Si tu ne peux toucher ni à Base, ni à derivedN, cela commence à devenir difficile :koi:
Pourquoi tes extensions doivent forcément être des extensions de Base ? Pourquoi ne pas avoir :
Code:

1 2 3 4 5 6 7 8 9 // non modifiable : class base{}; class derived : public base{}; // class modifiable : class my_extended_base{}; class my_derived : public derived, public my_extended_base {};

Citation:

Pourquoi tes extensions doivent forcément être des extensions de Base ? Pourquoi ne pas avoir

(On nommera DrawableBis la classe qui hérite de drawable comme dans mon exemple).
Supposons ceci :
Code:

1 2 3 4 5 6 7 8 9 class Fond { std::vector<DrawableBis*>MesImages; bool IsPointInside(const Point& P)const; void AddElement(const Drawable& D); void Draw(const RendeWindow& W); Fond(const Drawable& D); ~Fond(); };
Comment je fais pour "Draw" si j'ai un vector<my_extended_base*> ?

Je suis presque persuadé qu'il y a un DP pour ça. En gros, ça pourrait donner quelque chose comme ça :

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#include <iostream>
 
struct Drawable
{
    virtual void draw()const=0;
    virtual ~Drawable(){}
};
struct widget : public Drawable
{
    virtual void draw()const
    {
        std::cout<<"draw_widget\n";
    }
};
 
struct sprite : public Drawable
{
    virtual void draw()const
    {
        std::cout<<"draw_sprite\n";
    }
};
 
// extension :
struct DrawableBis
{
    virtual void meuh()const=0;
    virtual ~DrawableBis(){}
};
 
struct widget_cow : public DrawableBis
{
    virtual void meuh()const
    {
        std::cout<<"widget_meuh\n";
    }
};
 
struct sprite_cow : public DrawableBis
{
    virtual void meuh()const
    {
        std::cout<<"sprite_meuh\n";
    }
};
 
struct compound
{
        virtual Drawable const& get_drawable()const=0;
        virtual DrawableBis const& get_drawable_bis()const=0;
};
 
template<class drawable_t_, class drawable_bis_t_>
struct effective_coumpound : public drawable_t_, public drawable_bis_t_, public compound
{
    virtual Drawable const& get_drawable()const
    {
        return *this;
    }
    virtual DrawableBis const& get_drawable_bis()const
    {
        return *this;
    }
};
 
#include <vector>
#include <algorithm>
struct Fond
{
 
    std::vector<compound*>elements;
    void draw()const
    {// j'ai mis un lambda C++0x pour aller + vite
 
        std::for_each(elements.begin(),elements.end(),[](compound const*p_)
                      {
                          p_->get_drawable().draw();
                      }
        );
    }
    void meuh()const
    {
 
        std::for_each(elements.begin(),elements.end(),[](compound const*p_)
                      {
                          p_->get_drawable_bis().meuh();
                      }
        );
    }
};
 
int main()
{
    effective_coumpound<widget,widget_cow> effective_widget;
    effective_coumpound<sprite,sprite_cow> effective_sprite;
 
    Fond f;
    f.elements.push_back(&effective_widget);
    f.elements.push_back(&effective_sprite);
    f.draw();
    f.meuh();
    return 0;
}

[EDIT] avec des bonnes classes traits entre les deux yeux, tu dois pouvoir faire évoluer en // (si c'est ton besoin) les 2 hiérarchies (sprite/sprite_cow, widget/widget_cow and so on) pour déduire l'une à partir de l'autre :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
template<typename drawable_t_>
struct compound_drawable_trait;
template<>
struct compound_drawable_trait<sprite>
{
    typedef sprite_cow type;
};
 
template<>
struct compound_drawable_trait<widget>
{
    typedef widget_cow type;
};
 
template<class drawable_t_, class drawable_bis_t_>
struct effective_coumpound : public drawable_t_, public compound_drawable_trait<drawable_t_>::type, public compound
{

10/11/2010, 19h27
NoIdea

Merci 3DArchi, j'ai enfin compris ton premier code, je m'attaque à la compréhension du deuxième.
En tout cas, le premier fait déjà ce que je veux, je crois.
Merci beaucoup.
10/11/2010, 20h14
3DArchi

En fait, j'ai fait un peu ça à la va vite et je pense que ça doit être généralisable.

Juste une petite question avec new :
Supposons que j'ai une référence constante qui est passée dans une fonction, et que je veux copier l'objet. De plus, le type de l'objet est dynamique :
Code:

1 2 3 4 5 6 void AddElement(const Drawable& D) { //Je veux créer une copie identique a D, donc même type dynamique : Drawable*copie=new Drawable(D)// ? Sa ne marche pas : il créé pour un type statique. //Comment faire ? }
Merci.

Révisez vos classiques comme disait l'autre:mouarf: : Design pattern prototype

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
struct Drawable
{
virtual   Drawable*Clone()const=0;
};
 
struct derived : public Drawable
{
virtual derived *Clone()const{return new derived(*this);}
};
void AddElement(const Drawable& D)
{
Drawable*copie=D.Clone()
}