Template, héritage multiple et redéfinition

Version imprimable

Bonjour !

Voici le code qui me pose un problème :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include <iostream> using namespace std; template <class T> struct Mother { void func(T val) { cout << val << endl; } }; struct Child : public Mother<int>, public Mother<double> { }; int main(int argc, char** argv) { Child c; c.Mother<int>::func(314); return 0; };
Ce code fonctionne très bien en l'état. Mon problème est que je voudrais redéfinir dans "Child" la méthode "func" issu de l'héritage "Mother<int>".

Si je fais...
Code:

1 2 3 4 5 6 7 struct Child : public Mother<int>, public Mother<double> { void func(int val) { cout << "Fonctionnalité supplémentaire" << endl; Mother<int>::func(val); } };
... ça compile très bien mais ça ne fait pas ce que je veux car, en fait, cela ne redéfinit pas la méthode "func" issu de l'héritage "Mother<int>". Ainsi, si j'appelle "c.Mother<int>::func(314)" dans la fonction "main", seule la méthode "func" de la classe de base "Mother<int>" est appelée !

En fait, je voudrais faire quelque chose dont la syntaxe pourrait être...
Code:

1 2 3 4 5 6 7 struct Child : public Mother<int>, public Mother<double> { void Mother<int>::func(int val) { cout << "Fonctionnalité supplémentaire" << endl; Mother<int>::func(val); } };
... malheureusement, cette syntaxe n'est pas acceptée par les compilateurs :
G++ me dit : "error: cannot declare member function `Mother<int>::func' within `Child'"
et Visual C++ : "error C3240: 'func' : must be a non-overloaded abstract member function of 'Mother<T>'"

Merci pour vos réponses !

28/10/2006, 12h41
Jean-Marc.Bourguet

Si tu veux supplanter une fonction, il faut qu'elle soit virtuelle (donc ajouter virtual à Mother<T>::func)

Si tu veux pouvoir supplanter une fonction qui est ambigue car héritée deux fois, il me semble (mais je ne suis pas un champion de l'héritage multiple, j'ai plutôt tendance à choisir les alternatives) qu'il n'y a pas d'autres solutions que d'introduire un niveau de hiérarchie supplémentaire qui fournit un renommage. (Donc introduire une classe MotherInt qui renomme func en funcInt).
28/10/2006, 12h42
rigobert

Ne faudrait-il pas tout simplement que func soit virtuelle ??

EDIT: grilled :P
30/10/2006, 16h48
roulious

Citation:

Envoyé par Paul Atreide

cela ne redéfinit pas la méthode "func" issu de l'héritage "Mother<int>". Ainsi, si j'appelle "c.Mother<int>::func(314)" dans la fonction "main", seule la méthode "func" de la classe de base "Mother<int>" est appelée !

Ça redéfinit bien la fonction func de la classe mère, mais ton appel n'est pas correct : quand tu dis "c.Mother<int>::func(314)", tu appelles explicitement la fonction de la classe mère. Si tu appelles "c.func(314)" tu auras le comportement attendu.

De plus, comme disent Jean-Marc et rigobert, une fonction destinée à être supplantée devrait être déclarée virtuelle si tu veux pouvoir bénéficier du polymorphisme.

Merci pour vos réponses.

J'ai finalement opté pour une solution de la forme suivante :

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
 
#include <iostream>
 
using namespace std;
 
struct MotherInt {
    virtual void funcInt(int val) {
        cout << val << endl;
    }
};
 
struct MotherDouble {
    virtual void funcDouble(double val) {
        cout << val << endl;
    }
};
 
struct Child : public MotherInt, public MotherDouble {
    void funcInt(int val) {
        cout << "Fonctionnalités supplémentaires" << endl;
        MotherInt::funcInt(val);
    }
};
 
int main(int argc, char** argv) {
    Child c;
    c.funcInt(314);
    return 0;
};

31/10/2006, 15h00
Médinoc
(enfin, dans le cas présent, la virtualité n'est pas utilisée: ça marcherait aussi bien sans virtual...)

Dans ce cas-ci par contre, virtual est indispensable:
Code:

1 2 3 4 5 6 int main(int argc, char** argv) { MotherInt *pc = new Child; pc->funcInt(314); delete pc; return 0; };