Discussion :

[chrono23]

Salut!

j'ai utilisé un mécanismes d'héritage, mais lorsque je veux appeller une methode qui se trouve dans une classe-fille, le compilateur me dit que cette méthode n'est pas un membre de de la classe mere!

je comprend pas pourquoi il me dit ca???
y'a t-il quelque chose de pariculier a faire, sinon comment faire pour acceder a cette méthode?????

[Swoög]

Il faudrait que tu donnes un ECM (Exemple Complet Minimal), enfin un peu de code quoi, qu'on voit ce que tu as fait...

[Jean-Marc.Bourguet]

Salut!

j'ai utilisé un mécanismes d'héritage, mais lorsque je veux appeller une methode qui se trouve dans une classe-fille, le compilateur me dit que cette méthode n'est pas un membre de de la classe mere!

je comprend pas pourquoi il me dit ca???
y'a t-il quelque chose de pariculier a faire, sinon comment faire pour acceder a cette méthode?????

Si tu veux accèder à un membre de la classe fille, il faut le faire à travers un objet qui soit de ce type. Si tu as un pointeur vers la classe mère, même s'il pointe effectivement vers une instance de la classe fille, tu ne peux pas appeler les membres de la classe fille.

[chrono23]

ok vais faire le plus simple possible!

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
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
 
//A.h
class A
{
public:
   int var1;
   int var2;
public:  
   A();
   ~A();
   void fonction_a(param);
};
 
////////////////////////////
// A.cpp
A::A()
{
   ...;
}
A::~A()
{
   ...;
}
 
void A::fonction_a(param)
{
   ...;
}
////////////////////////////
//B.h
#include "A.h"
 
class B:public A
{
public:   
   int varB1;
   int varB2;
public:
   B();
   ~B();
   void fonctionB(param);
};
////////////////////////////
//B.cpp
B::B():A()
{
   ...;
}
B::~B():~A()
{
   ...;
}
 
void B::fonctionB(param)
{
   ...;
}
//////////////////////
//dans main
 
#include "A.h"
 
int main()
{
   A* ptr;
   ptr = new B();
   // acces à la méthode focntionB()
   ptr->fonctionB();  // ici le compilateur aime pas!!!
 
}

Le compilateur me dit que fonctionB n'est pas membre de A????!!!!!!!!

[chrono23]

Si tu veux accèder à un membre de la classe fille, il faut le faire à travers un objet qui soit de ce type. Si tu as un pointeur vers la classe mère, même s'il pointe effectivement vers une instance de la classe fille, tu ne peux pas appeler les membres de la classe fille.

Mon ptr est déclarer comme A, mais il instancie l'objet B, donc ca devrait marcher non????

[Swoög]

Comme l'a dit Jean-Marc, meme si le type reel de ton objet est B, son type declare est A, donc pour C++, fonctionB n'existe pas pour ton objet...

il te faut faire un static_cast : [code]static_cast<B*>(ptr)->functionB();[code]

[chrono23]

ouai mais a ce moment l'héritage ca sert pas a grand chose alors....

[Ti-R]

Si,
Soit,

Code :

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

1
2
3
4
5
6
class A
{
...
virtual void fonctionB(param)=0;
...
}

En « virtual pur » tu ne peux plus utiliser A directement

Soit

Code :

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

1
2
3
4
5
class A
{
...
virtual void fonctionB(param){};
}

Qui ne fait rien en A et peut être surchargé en B

D’ailleur un

Code :

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

virtual ~A();

ne serait pas de trop

[Jean-Marc.Bourguet]

ouai mais a ce moment l'héritage ca sert pas a grand chose alors....

Et comment veux-tu qu'il sache qu'il doit appeler un membre fonctionB de la classe B et pas de la classe C qui hérite aussi de A et a aussi un membre fonctionB?

[Swoög]

+1 à ce qu'à dit Ti-R, tu confonds héritage (extension d'une classe) et polymorphisme (modification du comportement d'une classe selon son type réel)

le premier peut mettre en jeu des fonctions n'existant pas dans la classe de base, alors que le second met simplement en jeu des fonctions virtuelles de la classe de base qui ont été redéfinies dans la classe dérivée

[chrono23]

Oui alors effectivement c'est bien un problème de polymorphisme.
J'ai essayé la méthode de la classe abstraite qui fonctionne bien sur(j y avais pas pense avant!)
Mais le problème c'est que je dois donc mettre toutes les méthodes de mes classe filles en virtual dans la classe mere, pour que ca marche.
Eh cela implique que que je dois coder toutes ces méthodes dans toutes les classes filles, ce qui fait que je vais me retrouver avec plein de méthodes NULL!!!

Et ca c'est pas terrible, c'est meme plutot moche???

[Ti-R]

Utilise la seconde solution
Virtual non pur.

Code :

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

1
2
3
4
5
class A
{
...
virtual void fonctionB(param){};
}

Cela évite d'hériter si ce n'est pas nécessaire.

[Laurent Gomila]

Et ca c'est pas terrible, c'est meme plutot moche???

Tout à fait... Si tu veux manipuler un B* là où tu as stocké un A*, tu as assurément un petit problème de conception.

Tu peux nous détailler un peu le contexte, et ce que tu cherches à faire ?

[chrono23]

C'est ce que j'ai fait mais le problème a ce moment c'est comme je l'ai dit plus haut: je dois faire toutes les méthodes d'accès de toutes les classes filles en virtual ce qui m'oblige a les coder dans chaque classe fille!
ou alors ce n'est pas necessaire et c'est moi qui débloque???
tu pense que je peux faire cela sans a avoir a coder les methodes dans chaque classe fille???

[Jean-Marc.Bourguet]

Utilise la seconde solution

Ça permet de résoudre les symptômes... mais est-ce que le problème de fond est réglé? J'ai des doutes sérieux sur la validité d'une conception qui nécessite d'implémenter des fonctions virtuelles qui ne sont jamais appelées. Les cas où les fonctions virtuelles ne fond quelque chose que dans une classe dérivées sont un peu plus nombreux, mais il me semble que la conception doit être remise en question quand ça arrive.

[chrono23]

Oui alors le contexte, c'est que je déclare A* car je ne sais pas quelle forme va prendre mon A, mais il va prendre la forme de une des classe filles, qui penvent donc être B,C,D,...
selon le type de chose que je dois modeliser, c'est donc du ploy morphisme typique.

je peux etre encore plus precis si vous voulez mais ca va faire pas mal de texte a lire.

[Jean-Marc.Bourguet]

Oui alors le contexte, c'est que je déclare A* car je ne sais pas quelle forme va prendre mon A

Mais tel que tu as rédigé ta question au départ, on a l'impression que quand tu appelles les fonctions, tu sais quelle forme a été choisie. Un static_cast (ou mieux un dynamic_cast pour vérifier l'hypothèse) peut être une meilleure solution qu'un paquet de fonctions membres virtuelles qui n'ont du sens que pour un seul descendant. Ou il est possible aussi que d'autres structures conviennent.

[chrono23]

je ne sais pas au moment de la déclaration quel forme mon *A va prendre, mais au moment de l'instanciation je saurai qu'il s'agit d'un B ou d'un C, ou D,...
j'essayé le static_cast et le dynamic_cast aussi, mais le compilo n'aime pas!

genre j'ecris ca:

Code :

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

1
2
3
4
5
 
 
SequenceTS[0]->payload
                            ->static_cast<*PATSection>(Section)
                                                            ->SetSection_number(0xAA);

Sequence contient des pointeurs de paquet. qui enx meme contiennet des pointeurs de payload, qui lui va contenir un pointeur de type Section, mais cette Section est une PATSection. et avec la methode SetSection_number je veux acceder un champ de la PATSection pointer par Section!

[chrono23]

mince c'est pas jolie:

c'est ca le code:

Code :

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

1
2
3
 
 
SequenceTS[0]->payload->static_cast<*PATSection>(Section)->SetSection_number(0xAA);

[Laurent Gomila]

Essaye comme ça :

Code :

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

static_cast<PATSection*>(SequenceTS[0]->payload->Section)->SetSection_number(0xAA);