polymorphisme, pointeurs et classes abstraites

Version imprimable

Salut !

J' essaye d' utiliser le polymorphisme: j' ai 1 classe abstraite "ATTRIBUT", qui herite de 2 autres classes, "COLOR" et "VERTEX". J' essaye d' utiliser tous cela à l' aide de pointeur, mais sans resultat:
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 class VERTEX { public: void function(void); }; class COLOR { public: void function(void); }; class ATTRIBUT: public VERTEX, public COLOR { public: virtual void function(void) = 0; }; int main() { ATTRIBUT *att; att = new VERTEX; delete att; att = new COLOR; delete att; return (0); }
Et le compilateur me dit que la conversion de VERTEX* à ATTRIBUT* est invalide...

Merci d' avance.

Salut.

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
#include <iostream>
 
using std::cout;
using std::endl;
 
class VERTEX
{
public:
    virtual void function(void) { cout << "VERTEX" << endl; }
};
 
class COLOR
{
public:
    virtual void function(void) { cout << "COLOR" << endl; }
};
 
class ATTRIBUT: public VERTEX, public COLOR
{
public:
    virtual void function(void) = 0;
}; 
 
int main()
{
    ATTRIBUT* att;
 
    att = reinterpret_cast<ATTRIBUT*>(new VERTEX);
    att->function();
    delete att;
 
    att = reinterpret_cast<ATTRIBUT*>(new COLOR);
    att->function();
    delete att;
 
    return (0);
}

02/11/2005, 08h51
Luc Hermitte

Tu hérites dans le mauvais sens. Et reinterpret_cast est tout sauf la bonne solution en situation d'héritage. Ce truc, c'est essentiellement pour sérialiser des données typées dans des séquences d'octets, ou bidouiller avec des callback d'anciennes API.

Pour compléter un peu la réponse de Luc, effectivement tu t'y prends dans le mauvais sens. Peut-être voulais-tu faire ça ?

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
class ATTRIBUT
{
public:
    virtual ~ATTRIBUT(); // <-- NE PAS L'OUBLIER !!
 
     virtual void function(void) = 0;
};
 
class VERTEX : public ATTRIBUT
{
public:
     void function(void);
};
 
class COLOR : public ATTRIBUT
{
public:
     void function(void);
};
 
 
int main()
{
     ATTRIBUT *att;
 
     att = new VERTEX;
     delete att;
 
      att = new COLOR;
      delete att;
 
      return (0);
}

02/11/2005, 14h04
legend666
Houlalalala. Apparemment, j' ai rien compris :roll: Dans code proposé par Loulou24, c' est donc ATTRIBUT qui herite de VERTEX et COLOR et pas le contraire ? Donc c'est ca l' heritage multiple ? Si oui, qu' est-ce que cette syntaxe:
Code:

1 2 3 4 class maClasse : public maClasse1, public maClasse2 { };
Si je comprends bien, ici maClasse1 et maClasse2 herite de maClasse , c-à-d que maClasse1 et maClasse2 "auront" les variables de maClasse, ou l' inverse: maClasse "aura" les variables de maClasse1 et maClasse2 ? Apperemment j' ai tout melanger :marteau: :marteau: :marteau:

Et en effet j' avais oublié de preciser le destructeur virtual (warning avec l' option -Wall)

Merci d' avance
02/11/2005, 14h17
Laurent Gomila

Citation:

Si je comprends bien, ici maClasse1 et maClasse2 herite de maClasse , c-à-d que maClasse1 et maClasse2 "auront" les variables de maClasse, ou l' inverse: maClasse "aura" les variables de maClasse1 et maClasse2 ? Apperemment j' ai tout melanger

Justement c'est ce qu'on te dit : tu t'y prends à l'envers. Dans ton exemple, c'est maClasse qui hérite de maClasse1 et maClasse2.

Citation:

Dans code proposé par Loulou24, c' est donc ATTRIBUT qui herite de VERTEX et COLOR et pas le contraire ?

Pareil, c'est VERTEX et COLOR qui héritent de ATTRIBUT.

Ok, je pense avoir compris: en fait moi je faisais:

Code:

1
2
3
4
5
6
7
8
9
10
 
class Class_Mere : public Class_Fille, public class Fille2
{
      //mauvais
};
 
class Class_Fille : public Class_Mere, public class_Mere2
{
      \\bon
};

:?:

02/11/2005, 15h48
Laurent Gomila

Yep, c'est ça.

Peut-être que la lecture d'un chapitre sur l'héritage t'aiderait à y voir plus clair si tu n'es pas à l'aise avec ça, pense à faire un tour du côté de la page cours.
02/11/2005, 16h25
legend666
Ok. En effet, je vais aller revoir tout ca :)

Mais juste 3 questions par simple curiosité:
1) Pourquoi doit on declarer le destucteur de la classe mère virtuelle ?
2)Si je faisais:
Code:

1 2 3 4 5 class X { virtual ~X() = 0; };
j' avais des erreurs de linkage:
Code:

1 2 3 /tmp/cczJBGMg.o(.gnu.linkonce.t._ZN5COLORD1Ev+0x2d): In function `COLOR::~COLOR[in-charge]()': : undefined reference to `ATTRIBUTE::~ATTRIBUTE [not-in-charge]()'
Il fallait en fait rajouter un corps à ~X (virtual ~X() { }). Donc: Pourquoi ?

3)Y a-t-il un autre avantage (ou desaventage) à declarer les fonction des classes filles "virtual" a part les réutiliser pour du polymorphisme ?

Merci d'avance.
02/11/2005, 16h34
Laurent Gomila

1) http://c.developpez.com/faq/cpp/?pag...UCTEUR_virtuel

2) Oui, il faut toujours donner un corps au destructeur, même s'il est virtuel pur. Pourquoi ? Parce que ton compilo va l'appeler à la destruction de l'objet.

3) Absolument aucun, ça sert juste au polymorphisme. Par contre je suppose que tu parlais de classe mère et non de classe fille (sachant qu'à partir du moment où une fonction est déclarée virtuelle, elle l'est implicitement dans toutes les classes dérivées).
02/11/2005, 16h44
legend666

Ok, merci pour ces explications final ! :D