Discussion :

[legend666]

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 :

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
 
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.

[moldavi]

Salut.

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
#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);
}

[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.

[Laurent Gomila]

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 :

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
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);
}

[legend666]

Houlalalala. Apparemment, j' ai rien compris 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 :

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

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

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

Merci d' avance

[Laurent Gomila]

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.

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.

[legend666]

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

Code :

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

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
};

:

[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.

[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 :

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

1
2
3
4
5
 
class X
{
     virtual ~X() = 0;
};

j' avais des erreurs de linkage:

Code :

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

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.

[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).

[legend666]

Ok, merci pour ces explications final !