Discussion :

[vichenze]

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

Code :

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

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 :

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

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 :

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

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

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

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

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.

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

[vichenze]

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

Elle retourne un int non ?

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 :

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

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

Mot.h:

Code :

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

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 :

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

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.

[Médinoc]

Wikipédia, en anglais:
http://en.wikipedia.org/wiki/Double_dispatch

[Fiquet]

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

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]

[vichenze]

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 :

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

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

Mot.h:

Code :

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

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 :

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

[Luc Hermitte]

Ce me parait douteux comme désign.