Question sur les fonctions virtuelles

Bonjour/bonsoir,

Je vient (encore et encore) vous demander de l'aide non-plus a cause d'un réel problème mais d'une interrogation a propos des fonctions virtuelle. Tout simplement comment fonctionnent-t'elle? J'ai fait un tour sur la sacro-sainte FAQ mais j'avoue ne pas vraiment comprendre.

Lorsque on a une classe B héritée d'une classe A, qu'on a déclarer un objet A mais qu'on l'a initialiser comment étant un B et qu'on souhaite appeler une fonction de B qui dérive de A il suffit de déclarer la fonction (dans la classe A) avec le mot-clef "virtual" devant non?

C'est ce que je fait mais... ca fonctionne pas, ca appelle la fonction de l'objet A. Je voudrait juste savoir si le mot-clef "virtual" est suffisant ou il faut faire autre chose.(Je ne donne pas de code source car j'ai juste besoin d'informations théoriques).
Merci pour votre précieuse aide!

Bonjour,

Citation:

---

Lorsque on a une classe B héritée d'une classe A, qu'on a déclarer un objet A mais qu'on l'a initialiser comment étant un B et qu'on souhaite appeler une fonction de B qui dérive de A il suffit de déclarer la fonction (dans la classe A) avec le mot-clef "virtual" devant non?

---

Comment as tu déclaré l'objet A ? Normalement ta classe A n'a pas à être déclarée, ses classes héritées le seront.

Ce petit encadré décrit parfaitement l'utilité et la forme de l'héritage, et le mot "virtual", il sert en quelque sorte à envoyer une fonction de ta classe héritée aux classes "enfant".

Citation:

---

Envoyé par Negatio

Bonjour/bonsoir,

Je vient (encore et encore) vous demander de l'aide non-plus a cause d'un réel problème mais d'une interrogation a propos des fonctions virtuelle. Tout simplement comment fonctionnent-t'elle? J'ai fait un tour sur la sacro-sainte FAQ mais j'avoue ne pas vraiment comprendre.

---

Toute la suite s'entends de manière schématique. Les implémentations peuvent être différentes, et vont aussi rajouter des points importants (comme la gestion des dynamic_cast<>).

Lorsqu'un objet de type A est créé, le compilateur réserve sizeof(A) bytes pour le stocker. Si A ne contient pas de fonction virtuelle, alors

Code:

---

1 2	sizeof(A) = (somme des tailles de toutes les données membres de A)

---

En mémoire, l'objet de type A est stocké sous la forme suivante

Code:

---

1 2 3 4 5

adresse de l'instance de A: donnée 1 (taille N) donnée 2 (taille P) ...

---

Si A contient au moins une fonction virtuelle, alors
[code]
sizeof(A) = (somme des tailles de toutes les données membres de A) + sizeof(void*)
[code]

Code:

---

1 2 3 4 5 6

adresse de l'instance de A: pointeur vers la table de fonctions virtuelle (vtable) donnée 1 (taille N) donnée 2 (taille P) ...

---

La vtable est commune à toutes les instance du même type dynamique (ce qui veut dire que les objets de type B dérivant de A ont une vtable différente, même si on y accède à partir d'une variable dont le type statique est A. Donc :

Code:

---

1 2 3 4 5 6

class B : public A { ... }   A a; // vtable == vtable de A B b; // vtable == vtable de B A* ab = &b; // vtable == vtable de B

---

La vtable est simplement une table de pointeurs sur fonction (plus exactement, de pointeurs sur méthode). Chaque entrée de la table correspond à une fonction virtuelle de la classe. L'ordre des fonctions dans la vtable est celui donnée dans le fichier source de la classe mère. Pour les classes dérivées, les nouvelles fonctions virtuelles sont ajoutée ensuite. Un exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

struct A { virtual void f1(); virtual void f2(); };   struct B : A { virtual void f3(); virtual void f1(); // surcharge de A::f1() };

---

On a les vtables suivantes :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

pseudo-type-dépendant-du-compilateur A::vtable[] = { &A::f1, &A::f2 };   pseudo-type-dépendant-du-compilateur B::vtable[] = { &B::f1, &A::f2, &B::f3 };

---

Il ne reste plus qu'à accéder à ces fonctions. Comment fait-on ? C'est en fait très, très simple. Chaque objet a une adresse. Lorsqu'on accède à un membre de l'objet, cette adresse est mappée sur le pointeur this. Du coup, le compilateur ne fait que transcrire en assembleur la ligne de code suivante :

Code:

---

1 2 3 4 5

// B b; // A *ab = &b; // ab->f1(); this->vtable[index de f1() dans la table]

---

L'index est connu au moment de la compilation - donc le compilateur peut aisément accéder à la fonction souhaitée.

Citation:

---

Envoyé par Negatio

Bonjour/bonsoir,

Lorsque on a une classe B héritée d'une classe A, qu'on a déclarer un objet A mais qu'on l'a initialiser comment étant un B et qu'on souhaite appeler une fonction de B qui dérive de A il suffit de déclarer la fonction (dans la classe A) avec le mot-clef "virtual" devant non?

C'est ce que je fait mais... ca fonctionne pas, ca appelle la fonction de l'objet A. Je voudrait juste savoir si le mot-clef "virtual" est suffisant ou il faut faire autre chose.(Je ne donne pas de code source car j'ai juste besoin d'informations théoriques).
Merci pour votre précieuse aide!

---

D'abord, quelques pitites définitions :

Le type statique est le type de l'objet tel que vu par le compilateur. Par exemple :

Code:

---

1 2 3

A a; // type statique : A A *a; // type statique: A*

---

Le type dynamique (attention pour les puristes : je fait une simplification outrancière, histoire d'expliquer le truc) est le type réel de l'objet, tel qu'il a été créé. Cependant, le type dynamique ne survit pas à ce qu'on appelle le slicing - c'est à dire le fait de copier un objet d'un type donné dans un objet d'un type parent.

Code:

---

1 2 3 4

A a: B b; // B dérive de A a = b; // copie ==> slicing ==> le type dynamique de a est A.

---

De fait, puisque le slicing détruit le type dynamique, on ne parle pas de type dynamique dans ce cas (note pour les puristes : l'honneur est sauf, hein ?). On réserve cette locution aux types pointé via un pointeur ou une référence (du point de vue du code généré, ces deux entités se comportent de manière très similaires).

Code:

---

1 2	A *a = &b; // type statique: A* ; type dynamique : B*

---

Maintenant, la conclusion : pour qu'une donnée de type statique A puisse appeler une fonction surchargée dans une classe dérivée, il faut que le type dynamique de l'objet soit cette classe dérivée.

Concrètement, il faut passer par un pointeur ou une référence.

Code:

---

1 2 3 4 5 6

B b; A a = b; a.f1(); // appelle A::f1(); A *ab = &b; ab->f1(); // appelle B::f1();

---

J'en profite pour t'informer d'un détail subtil.
Tu risques un jour de rencontrer une erreur "unable to find symbol for `vtable' for type Machin"
Ce message signifie que l'éditeur de liens n'a pas trouvée cette fameuse table de fonctions virtuelles.

La raison est que cette table n'est correctement définie que si (au moins) une fonction virtuelle n'est pas inline, c'est-à-dire qu'elle est définie dans un fichier .cpp, non dans un en-tête (dans la déclaration de la classe ou avec le mot clé inline).

A titre indicatif, je viens de trouver un article traitant du même sujet sur embedded.com

Storage layout for polymorphic objects

Un autre article peut aussi être intéressant à lire :

Virtual functions in C.

Enfin, histoire de voir comment c'est implémenté en pratique, je conseille la lecture du code source de cfront, le compilateur C++ originel (créé par Bjarne Stroustrup lui-même). cfront transforme du code C++ en code C (attention toutefois : la dernière version date de 1991 et il lui manque un certain nombre de choses - comme les exceptions, etc...).

Tout d'abord merci a vous pour ces réponses très complètes!

Citation:

---

Comment as tu déclaré l'objet A ? Normalement ta classe A n'a pas à être déclarée, ses classes héritées le seront.

---

Je ne comprend pas vraiment ce que tu veut dire. J'ai une classe quelconque, dans son header j'ai écrit:

Code:

---

A objet;

---

Et puis dans le constructeur de cette classe quelconque j'ai fait:

Code:

---

objet = b();

---

Je voit pas ce que tu veut dire par "déclarer une classe", il faut que je créer la classe A pour que B puisse en hérité non?

Citation:

---

La vtable...

---

J'ai vraiment mal chercher je pense pars-ce-que j'ai rien trouver de semblable. Je savait pas que ca exister.

Citation:

---

Concrètement, il faut passer par un pointeur ou une référence.

---

Encore eux! Je me suit jamais douter qu'il faut utiliser ça.

Citation:

---

J'en profite pour t'informer d'un détail subtil.
Tu risques un jour de rencontrer une erreur "unable to find symbol for `vtable' for type Machin"
Ce message signifie que l'éditeur de liens n'a pas trouvée cette fameuse table de fonctions virtuelles.

La raison est que cette table n'est correctement définie que si (au moins) une fonction virtuelle n'est pas inline, c'est-à-dire qu'elle est définie dans un fichier .cpp, non dans un en-tête (dans la déclaration de la classe ou avec le mot clé inline).

---

Je m'en rappellerais (peut-être) en temps voulu.

Citation:

---

A titre indicatif, je viens de trouver un article traitant du même sujet sur embedded.com

Storage layout for polymorphic objects

Un autre article peut aussi être intéressant à lire :

Virtual functions in C.

---

Je vais surpasser mon anglophobie pour lire ça

Citation:

---

Enfin, histoire de voir comment c'est implémenté en pratique, je conseille la lecture du code source de cfront, le compilateur C++ originel (créé par Bjarne Stroustrup lui-même). cfront transforme du code C++ en code C (attention toutefois : la dernière version date de 1991 et il lui manque un certain nombre de choses - comme les exceptions, etc...).

---

Ca existe ça?! Bon ben je vais y jeter un gros coup d'oeuil.

Encore merci énormément pour vos précieux conseils.

Bonjour,

Citation:

---

Citation:

---

Citation:
Concrètement, il faut passer par un pointeur ou une référence.

---

Encore eux! Je me suit jamais douter qu'il faut utiliser ça.

---

Ces notions de pointeurs et références devront être très clair pour entamer la suite !

Citation:

---

Envoyé par Emmanuel Deloget

A titre indicatif, je viens de trouver un article traitant du même sujet sur embedded.com

Storage layout for polymorphic objects

Un autre article peut aussi être intéressant à lire :

Virtual functions in C.

Enfin, histoire de voir comment c'est implémenté en pratique, je conseille la lecture du code source de cfront, le compilateur C++ originel (créé par Bjarne Stroustrup lui-même). cfront transforme du code C++ en code C (attention toutefois : la dernière version date de 1991 et il lui manque un certain nombre de choses - comme les exceptions, etc...).

---

C'est dommage qu'il n'y rien de plus récent.
Je suis curieux de voir la compil en C d'un code C++11 avec des lambda, des move reference et autres joyeusetés.
:D

Citation:

---

Ces notions de pointeurs et références devront être très clair pour entamer la suite !

---

Je sait bien mais je préférais faire sans. Je comprend la théorie mais en pratique ca me pose toujours quelque problème. Enfin, faut bien que je passe par là!

Citation:

---

Envoyé par camboui

C'est dommage qu'il n'y rien de plus récent.
Je suis curieux de voir la compil en C d'un code C++11 avec des lambda, des move reference et autres joyeusetés.
:D

---

Ah mais tu peux !

Je te conseille de checker LLVM - avec ça, tu peux construire un compilateur - et tu peux surtout instrumenter le code qui permet de construire un compilateur.

Citation:

---

Envoyé par Negatio

Je sait bien mais je préférais faire sans. Je comprend la théorie mais en pratique ca me pose toujours quelque problème. Enfin, faut bien que je passe par là!

---

Il est impossible de faire sans.
La virtualité et le polymorphisme fait appel au type dynamique de l'objet. Non au type statique.

Code:

---

1 2 3 4 5

A myA; // type statique A, type dynamique A B myB; // type statique B, type dynamique B A* pA = &myA; // type statique A, type dynamique A pA = &myB; // type statique A, type dynamiqye B

---