Discussion :

[chronos]

Bonjour,

Je suis en train d'essayer de faire quelque chose qui ressemble à ça:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
struct A
{
	void Foo()
	{std::cout<<"Foo from IA"<<std::endl;}
};
 
struct Base
{
	virtual void Foo() = 0;
};
 
class Derived : public Base, public A
{};

J'aimerais que la class Derived prenne comme implémentation de Foo, celle définie dans A. Y'a t'il un moyen de faire cela. L'idée étant que dans la class Base il soit possible d'appeler Base::Foo() qui "pointerait" vers l'impleme contenue dans A...

[screetch]

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
struct A
{
	void Foo()
	{std::cout<<"Foo from IA"<<std::endl;}
};
 
struct Base
{
	virtual void Foo() = 0;
};
 
class Derived : public Base, public A
{
    virtual void Foo() { return A::Foo(); }
};

a noter que c'est pas forcément la meilleure idée, cela rend le code confus (si tu as des problèmes pour ecrire ce code, imagine ce que ce sera pour lire ce code?)

[chronos]

Pas faux, j'avais cette solution mais elle ne me plait pas dans le sens ou dans Derived on doit définir Foo, ce que je veux justement éviter :s

[oodini]

Sinon, hériter de B de manière privée résoudrait peut-être ton problème, mais cela va peut-être en créer d'autres. :-)

[chronos]

Sinon, hériter de B de manière privée résoudrait peut-être ton problème, mais cela va peut-être en créer d'autres. :-)

Ca n'a pas l'air de solutionner grand chose, je penche de plus en plus vers un problème de design moisi en fait :s Je vais faire autrement histoire que ce soit moins tordu.

Merci, je passe en résolu même si ça ne l'ai pas vraiment

[koala01]

Salut,

Déjà, je me pose sérieusement la question de savoir si les deux classes de base ont réellement besoin de la fonction foo...

Je m'explique:

Si tu as séparé Base et A, c'est parce que tu estime que la responsabilité de Base est différente de celle de A, et donc, que les services que tu es en droit d'attendre de Base n'ont rien à voir avec ceux que tu es en droit d'attendre de A.

Par exemple, Base pourrait fournir une fonction draw(), mais pas une fonction move() alors que A fournirait la fonction move() et pas la fonction draw().

Cela te permettrait de créer :

• Des classes dérivées susceptible d'être déplacées (car héritant de A) mais incapables d'être tracées,
• des classes susceptibles d'être tracées (car héritant de Base) mais pas d'être déplacées
• et, enfin, des classes susceptibles d'être tracées et déplacées car héritante de Base ET de A

Malheureusement, hors de tout contexte, il est très difficile de se faire une idée précise de la manière de s'y prendre

De plus, je tiens à rappeler que l'héritage est la relation la plus forte qui puisse exister entre deux classes, et qu'il doit donc être considéré avec une extrême prudence (entre autre en veillant à respecter srcupuleusement le LSP )!!!

L'héritage multiple, loin de faire exception, nécessite une attention encore beaucoup plus importante