[Problème] Surchage de fonction avec parametre ou retour hérité
Bonjour,
je me retrouve face à une problèmatique que je crois être élémentaire et voilà ,en gros, de quoi il retourne.
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
|
class Comparable
{
public :
Comparable(){};
virtual ~Comparable(){};
virtual int compare(Comparable & _oCompareTo);
//les fonctions ci dessous ne font qu'appeler la fonction ci dessus
virtual void compare(Comparable & _oCompareTo, EComparison & _eComparison, EAmplitude & _eAmplitude);
virtual int compare(Comparable * _pCompareTo);
virtual void compare(Comparable * _pCompareTo, EComparison & _eComparison, EAmplitude & _eAmplitude);
};
class StringCaracterizedObject : public Comparable
{
[...] //rien d'intéressant là dedans
}
class Attribute : public StringCaracterizedObject
{
public :
//là, je pense overrider 'virtual int Comparable::compare(Comparable & _oCompareTo);' , j'analyse bien ?
virtual int compare(Attribute & _oCompareTo);
}
class AttributeFull : public Attribute
{
public :
//là pareil , je pense overrider 'virtual int Attribute::compare(Attribute & _oCompareTo);' , j'analyse bien ?
virtual int compare(AttributeFull & _oCompareTo);
}
void StratChoiceAttributeForCo::Execute(AttributeList * _pElectedList)
{
for(AttributeTree::iterator it = m_pCandidates->begin();
it != m_pCandidates->end(); ++it)
{
Attribute * p = (Attribute*)(it.node->data);
if(p->GetValueString().compare("")!=0)
p = dynamic_cast<AttributeFull*>(p);
if(p)
{
std::string strCurentName = *p->GetPath();
int t = ConversionToolBox::sCombineComparisonAndAmplitude(m_eRefRelationType,m_eRefRelationAmplitude);
Attribute * pAttrib = m_pReference->Find(strCurentName);
if(pAttrib->GetValueString().compare("")!=0)
pAttrib = dynamic_cast<AttributeFull*>(pAttrib);
//Le problème vient de là : même si pAttrib et p sont convertis en AttributeFull, la fonction appelée est Attribute::compare()
int result = p->compare(*pAttrib);
}
}
} |
Bref, j'ai un peu du mal à saisir le comportement du compilateur ou du programme à l'éxécution lorsqu'on a une hiérarchie du type :
Code:
1
2
3
4
5
6
7
8
9
10
|
class A
{
virtual int f(A* _a)
}
class B : A
{
virtual int f(B* _b)
} |
Je m'attendrais à ce que, si le virtual n'est pas bien identifiée, B::f(B* _b) puisse être identifiée par sa signature... mais je crois que je loupe quelquechose. J'ai trouvé ce thread, mais il ne couvre pas le même problème il me semble.
