héritage virtuel multiple
Bonjour,
j'aurais besoins de vos lumières :mrgreen:
J'ai déjà regardé par-ci par-là différents articles, mais je n'ai pas trouvé ce que je cherche ou je n'ai pas compris les solutions qui étaient présentées.
Voici la liste des différents objets que j'aimerai définir.
Contrainte: classe définissant des propriétés sur les contraintes. Contient des méthodes virtuelles pures et d'autres non pure.
IntegerContrainte: une contrainte sur les entiers dispose d'une propriété en plus que les autres contraintes. Propriété définie par méthode virtuelle pure
ConjonctionContrainte : C'est une contrainte qui implémente les méthodes virtuelles pures de la classe Contrainte
Addition: une contrainte sur les entiers: défini les méthodes virtuelles pures de "Contrainte" et "IntegerContrainte"
ConjonctionIntegerContrainte : C'est une "ConjonctionContrainte" qui doit également implémenter les méthodes de "IntegerContrainte"
Malheureusement, je ne sais pas exactement comment je dois définir la hiérarchie de classe. Pour l'instant, j'ai défini dans "IntegerContrainte" uniquement la méthode virtuelle pure liée aux contraintes sur les entiers et donc la classe Addition hérite de Contrainte et IntegerContrainte. Je me suis dit qu'en faisant ainsi je sépare bien les choses et je n'ai pas d'ambiguïté pour les appels aux fonctions.
Cependant, le soucis que je rencontre actuellement, c'est que lorsque j'appelle la fonction relative aux contraintes sur les entiers de ma classe "Addition", ce n'est pas la bonne fonction qui est exécutée :aie:
Voici ce à quoi ressemble le code:
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
|
template<typename T>
class Constraint {
public:
virtual ~Constraint() { }
virtual bool isSatisfiable() const throw (ConstraintException) = 0;
virtual bool nodeConsistent() { ... }
}
template<typename T>
class ConjunctionConstraint : public Constraint<T> {
public:
virtual bool isSatisfiable() const throw (ConstraintException) { ... }
virtual bool nodeConsistent() {...}
}
class IntegerConstraint {
public:
virtual ~IntegerConstraint() {...}
virtual bool boundsConsistent() = 0;
}
class AdditionConstraint : public Constraint<int>, public IntegerConstraint {
public:
virtual bool boundsConsistent() {...}
virtual bool isSatisfiable() const throw (ConstraintException) { ... }
virtual bool nodeConsistent() {...}
}
//ne contient qu'une seule méthode: celle nécessaire pour IntegerConstraint, se repose sur les implémentations de ConjunctionConstraint pour tout le reste
class IntegerConjunction : public ConjunctionConstraint<int>, public IntegerConstraint {
public:
virtual bool boundsConsistent(){
...
Constraint<int>* c = itc->next();
if (dynamic_cast<IntegerConstraint*> (c)) {
IntegerConstraint* ic = (IntegerConstraint*) c;
bc = ic->boundsConsistent();
}
....
}
} |
Et le soucis, c'est qu'au moment où il faut effectuer ic->boundsConsistent(); (la deuxième fonction virtuelle de IntegerConstraint), un appel est effectué à la fonction "isSatisfiable" (qui est la deuxième fonction virtuelle de Constraint) au lieu d'appeler la bonne fonction.
J'ai cru voir que je dois éventuellement ajouter des "virtual" lorsque je déclare l'héritage. J'ai fait des essais mai je pense pas avoir bien compris car je n'ai rien obtenu de concluant :calim2:
Donc je me pose la question de savoir comment je dois organiser ma hiérarchie? Si vous avez des idées, je suis preneur :-)
PS: j'ai plus d'expérience en java ce qui fait que je n'ai peut-être pas la bonne pratique pour des spécificités du C++ ...
