classe abstraite

Version imprimable

14/03/2006, 13h45
vichenze

classe abstraite
Bonjour,
J'ai une classe abstraite Element.h:
Code:

1 2 3 4 5 6 class Element { public : virtual void affiche() {}; virtual int compare(Element*) {}; };
Une classe Mot qui hérite d'élément, Mot.h:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class Mot:public Element{ private: string info; int occurence; public: Mot(string M); void affiche(); int compare(Mot* M); };
Mot.cpp:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 Mot::Mot(string M) { info = M; occurence = 1; } void Mot::affiche() { cout << "mot: " << info; } int Mot::compare(Mot* M) { if ... return res; }
Problème: j'arrive à faire un x->affiche() avec x pointeur sur un élément, par contre je ne peux pas faire de res = x->compare(y) avec y un pointeur sur élément aussi.
Le méthode compare ne s'éxécute pas (si je met un cout dans compare rien ne s'affiche par exemple), res prend une valeur absurde.

Je ne comprend pas trop pourquoi dans un cas ça marche et pas dans l'autre.

Merci d'avance pour votre aide.
14/03/2006, 13h46
Médinoc

Ta classe Element n'est pas abstraite, ses fonctions membres sont virtuelles mais pas virtuelles pures.
Et l'implémentation de Element::Compare() ne retourne rien.

De plus, tes implémentations de Compare() doivent avoir exactement le même prototype: Ici, elles sont considérées comme deux fonctions différentes, alors c'est Element::Compare(Element *) qui est appelée (et dont l'implémentation est bugguée, voir plus haut).

PS: Active plus de warnings, le bug de Element::Compare() aurait dû être signalé.
14/03/2006, 13h50
swirtel
on peut voir ton instanciation ?

comme dit précédemment, tu n'as pas de méthodes virtuelles pûres.

par contre, ta méthode compare dans ta classe 'Element' ne retourne pas de valeurs.

Tu devrais la déclarer pure.
Code:

1 2 3 4 5 class Element { public: virtual int compare(Element *) = 0; };
De plus, et je viens de le voir, tes deux methodes compare n'ont pas la même signature, donc il ne s'agit pas de polymorphisme.
14/03/2006, 13h52
Laurent Gomila

Pour avoir ce genre de comportement nécessitant deux liaisons dynamiques, tu ne pourras pas utiliser une fonction virtuelle, à moins d'y aller à coup de dynamic_cast dans chaque implémentation de la fonction.

Fais une recherche sur le double dispatching, il me semble que c'est ce qui résoud le problème.

Citation:

Et l'implémentation de Element::Compare() ne retourne rien.

Elle retourne un int non ?

Citation:

De plus, tes implémentations de Compare() doivent avoir exactement le même prototype: Ici, elles sont considérées comme deux fonctions différentes, alors c'est Element::Compare(Element *) qui est appelée (et dont l'implémentation est bugguée, voir plus haut).

ok, ça me génais de mettre Element dans la classe mot, parce que de toutes façon, un mot sera forcemment comparer à un autre mot.

J'ai modifié comme ça:

Element.h
Code:

1 2 3 4 class Element { public : virtual void affiche() {}; virtual int compare(Element *) = 0;}
Mot.h:
Code:

1 2 3 4 5 6 7 8 9 10 11 class Mot:public Element{ private: string info; int occurence; public: Mot(string M); void affiche(); string getInfo(); int compare(Element* E);}
Mot.cpp
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 Mot::Mot(string M) { info = M; occurence = 1; } void Mot::affiche() { cout << "mot: " << info; } string Mot::getInfo() { return (info); } int Mot::compare(Element* E) { string chaineCour = info; string chaineAcompar = E->getInfo(); int long1 = chaineCour.length(); int long2 = chaineAcompar.length(); int res = 0; cout << "long1: " << long1 << endl; // juste un test pour vérifier qu'il rentre dans la fonction cout << "long2: " << long2 << endl; if (long1 != long2) res = -1; else ... // vérif caractère par caractère return res; }
Mais l'erreur est maintenant: Mot.cpp 'class Element' has no member named 'getInfo' ce qui est normal puisque getInfo est spécifique à Mot.

Citation:

Fais une recherche sur le double dispatching, il me semble que c'est ce qui résoud le problème.

J'ai cherché sur google, mais je n'ai pas trouver d'endroit où il est décrit précisemment comment mettre en oeuvre cette technique, tu n'as pas un lien ?

Merci de vos réponses.

14/03/2006, 15h01
Médinoc

Wikipédia, en anglais:
http://en.wikipedia.org/wiki/Double_dispatch
14/03/2006, 15h03
Fiquet

Citation:

Envoyé par vichenze

Mais l'erreur est maintenant: Mot.cpp 'class Element' has no member named 'getInfo' ce qui est normal puisque getInfo est spécifique à Mot.

C'est de ça que t'avais prévenu Loulou, tu dois caster ton Element* en Mot* avec dynamic_cast, ce qui est toujours dangereux (voir FAQ).

Citation:

Envoyé par vichenze

J'ai cherché sur google, mais je n'ai pas trouver d'endroit où il est décrit précisemment comment mettre en oeuvre cette technique, tu n'as pas un lien ?

Moi non plus et cela m'intresse aussi ;).

[edit] Merci Médinoc :) [/edit]

Merci beaucoup pour ce lien ;)

J'ai compris le principe, par contre j'ai du mal à l'appliquer pour mon cas.
J'ai fait ça:
Element.h

Code:

1
2
3
4
5
6
 
class Element {
     public :
     virtual void affiche() {};
     virtual int compare(Element *) = 0;
};

Mot.h:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class Mot:public Element{
   private:
      string info;
      int occurence;
 
   public:
      Mot(string M);
      void affiche();
      string getInfo();
      int compare(Mot* E);
      int compare(Element* E);
};

Mot.cpp:

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
 
Mot::Mot(string M)
{
   info = M;
   occurence = 1;
}
 
void Mot::affiche()
{
   cout << "mot: " << info;
 
string Mot::getInfo()
{
   return (info);
}
 
int Mot::compare(Element* E)
{
  return (E->compare(this));
}
 
int Mot::compare(Mot* E)
{
...      
}

Ca compile mais j'ai une erreur de segmentation, j'ai dû me planter dans un pointeur quelque part.

17/03/2006, 00h02
Luc Hermitte

Ce me parait douteux comme désign. :?