Discussion :

[nosferatu]

Bonjour,

J'aimerai savoir comment les méthodes virtuelles sont gérées en C++ surtout lors de l'héritage...

Je sais que lorsqu'une méthode est déclarée virtuelle, le compilateur crée une vtable, un tableau de pointeur de méthodes, dans la classe. Ce que je ne comprends pas, c'est comment le programme "sait", à l’exécution, quel élément de la table représente bien le pointeur vers la méthode appelée...

La seule possibilité que je vois est d'associer à chaque méthode un ID et que la vtable soit donc un tableau associatif ID <-> méthode... mais cela me semble peut efficace.

Quelqu'un sait-il comment cela est réellement implémenté par le compilateur ?

De plus si une classe hérite de deux autres classes avec des méthodes virtuelles, possède-t-elle 2 vtable ?

D'avance, merci

[screetch]

1) chaque méthode a un index.
C'est possible car pour hériter le compilateur doit avoir la définition de la classe sous les yeux

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class A
{
  virtual ~A(); // méthode 0
  virtual void doStuff(); // méthode 1
};
 
class B : public A
{
  virtual ~B(); // méthode 0, car remplace ~A();
  virtual int getParameter(); // méthode 2
  virtual void doStuff(); // méthode 1, remplace la méthode 1
};

lors de l'appel d'une méthode, le compilateur va connaître son index (puisque tu dois avoir la définition de la classe aussi)
d'où le code généré

Code :

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

1
2
3
4
a->doStuff();
// Method* vtable = a->__vtable__;
// Method m = vtable[1];
// m();

2) oui il y a deux vtable lors de l'héritage multiple

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
class A
{
  virtual ~A(); // méthode 0
  virtual void doStuff(); // méthode 1
 
  int bidule;
};
 
class B
{
  virtual ~B(); // méthode 0
  virtual int getParameter(); // méthode 1
 
  int machin;
};
 
class C : public A, public B
{
  virtual ~C(); // méthode 0 de la vtable 1 ET de la vtable 2
  virtual int getParameter(); // méthode 1 de la vtable 2, méthode 2 de la vtable 1
  virtual void doStuff(); // méthode 1 de la vtable 1, méthode 2 de la vtable 2
 
  int truc;
};

la classe C ressemble a ca:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
C
{
  // ici on a A
  Method* __vtable1__;
  int bidule;
 
  // ici on a B
  Method* __vtable2__;
  int machin;
 
  // et enfin C
  int truc;
};

on a donc deux vtable légèrement différentes

si on a un A* qui polymorphiquement est en fait un C, on va utiliser la vtable 1
si on a un B* qui polymorphiquement est en fait un C, on va utiliser la vtable 2

[nosferatu]

Clair, précis, sans tache !
Un tout grand merci, ça m'a vraiment bien aidé à comprendre !

[tomayo]

Mum, je ne peux que faire la pub d'un excellent tutorial present sur ce site:

Les fonctions virtuelles en C++: types statiques et types dynamiques

rédigé par 3DArchi (novembre 2009)

En complement d'un cours officiel sur le C++ (livre de Claude Delannoy ou, si t'as pas trop d'argent , le livre en ligne de Christian Casteyde), tu seras le roi des fonctions virtuelles.

Bon, pour les details techniques des implementation, cela depend des compilos (voir le tutorial, c'est aborde rapidement) donc la il ta faudra des recherches poussees.

PS: tu devrais mettre la discussion en resolu

A+