Différence entre un appel de fonction virtuel et non virtuel de la fonction?

Si virtualism/répartition dynamique est strictement définie par l'implémentation, la plupart(lire tous connu) compilateurs mettre en œuvre, en utilisant vptr et vtable.

Cela dit, la différence entre l'appel d'une non virtuel de la fonction et de la fonction virtuelle est:

Non-fonctions virtuelles sont résolus statically à Compile-time, Tandis que les fonctions Virtuelles sont résolus dynamically à Run-time.

Pour atteindre cette flexibilité de pouvoir décider quelle fonction appeler au moment de l'exécution,
il y a un peu de surcharge dans le cas de fonctions virtuelles.

Supplémentaires fetch appel qui doit être fait et c'est la surcharge/prix que vous payez pour l'utilisation de la dynamique de l'expédition.

En cas de non-virtuel de la fonction de la séquence d'appels est:

fetch-call

Le compilateur a besoin de fetch l'adresse de la fonction, puis call.

Alors que dans le cas de fonctions virtuelles, la séquence est:

fetch-fetch-call

Le compilateur a besoin de fetch la vptr de la this, puis fetch l'adresse de la fonction à partir de la vptr et puis call la fonction.

C'est juste une explication simplifiée de la séquence réelle peut-être beaucoup plus complexe que cela, mais c'est ce que vous avez vraiment besoin de savoir, On n'a pas vraiment besoin de savoir la mise en œuvre nitty gritty.

Bonne Lecture:

Héritage & Fonctions Virtuelles

OriginalL'auteur Alok Save

Lors de l'appel d'une méthode virtuelle, il doit rechercher quelle fonction appeler une fonction virtuelle table.

OriginalL'auteur icktoofay

Non-membre virtuel fonctions sont résolus de manière statique. fonction de membre sont liaison statiquement à la compilation en fonction du type du pointeur de la souris (ou de référence) à l'objet.

En revanche, virtuel fonctions de membre sont de liaison de manière dynamique au moment de l'exécution. Si les élèves ont au moins une fonction membre virtuelle puis compilateur met un pointeur caché dans l'objet appelé un vptr(table virtuelle adresse) lors de la construction de l'objet.

La compilateur crée un v-table pour chaque classe qui a au moins une fonction virtuelle. Table virtuelle contenir virtuel adresse de la fonction. Il peut être de tableau ou de la liste(dépend du compilateur) de la fonction virtuelle du pointeur

Lors d'un envoi d'une fonction virtuelle, le système d'exécution suivante de l'objet v-pointeur(chercher l'adresse de la classe de l'objet) de la classe v-table, puis décalage est ajouté à l'adresse de base(vptr) et d'appeler la fonction.

La espace-coût surcharge de la technique ci-dessus est nominale: un pointeur supplémentaire par objet (mais seulement pour les objets qu'il sera nécessaire de faire de liaison dynamique), plus un supplément de pointeur par méthode (mais seulement pour les méthodes virtuelles).
Le temps-coût surcharge est également assez minime: par rapport à la normale de la fonction d'appel, un appel de fonction virtuelle nécessite deux extra-extrait (un pour obtenir la valeur de la v-pointeur, une seconde pour obtenir l'adresse de la méthode).

Rien de tout cela exécution de l'activité se produit avec les fonctions virtuelles, puisque le compilateur résout non-fonctions virtuelles exclusivement au moment de la compilation en fonction du type du pointeur.

J'ai pris l'exemple simple pour comprendre au mieux, la manière dont la liaison qui s'est passé pour les non virtuel de la fonction & fonction virtuelle et comment fonction virtuelle mécanisme fonctionne.

#include<iostream>
using namespace std;
class Base
{
        public:
                virtual void fun()
                {}
                virtual void fun1()
                {}

                void get()
                {
                        cout<<"Base::get"<<endl;
                }
                void get1()
                {
                        cout<<"Base::get1"<<endl;
                }
};

class Derived :public Base
{
        public:
                void fun()
                {
                }
                virtual void fun3(){}
                void get()
                {
                        cout<<"Derived::get"<<endl;
                }
                void get1()
                {
                        cout<<"Derived::get1"<<endl;
                }

};
int main()
{
    Base *obj = new Derived();
    obj->fun();
    obj->get();
}

Comment la vtable créé pour la Base & classe dérivée

Code assembleur généré pour une meilleure compréhension.

$ g++ virtual.cpp -S -o virtual.s

J'ai récupéré les informations de la vtable de virtuel.s de Base et la classe Dérivée respectivement:

_ZTV4Base:
        .quad   _ZN4Base3funEv
        .quad   _ZN4Base4fun1Ev
_ZTV7Derived:
        .quad   _ZN7Derived3funEv
        .quad   _ZN4Base4fun1Ev
        .quad   _ZN7Derived4fun3Ev

Comme vous pouvez le voir fun & fun1 ne sont que deux des fonctions virtuelles dans la classe de Base. Vtable de la classe de Base(_ZTV4Base) ont des entrées à la fois des fonctions virtuelles. Vtable n'a pas d'entrée de fonction non virtuelle. S'il vous plaît ne pas confondre avec le nom de l'amusement(ZN4Base3funEv) & fun1(ZN4Base4fun1Ev), leurs noms ont été déformés.

Classe dérivée vtable des arbres entrées

1. plaisir(_ZN7Derived3funEv) remplacer la fonction
2. fun1(_ZN4Base4fun1Ev) héritée de la classe de Base
3. fun3(_ZN7Derived4fun3Ev) nouvelle fonction dans la classe dérivée

Comment non virtuel de la fonction & fonction virtuelle appelée?

pour les non-fonction virtuelle

    Derived d1;
    d1.get();

    subq    $16, %rsp
    leaq    -16(%rbp), %rax
    movq    %rax, %rdi
    call    _ZN7DerivedC1Ev //call constructor
    leaq    -16(%rbp), %rax
    movq    %rax, %rdi
    call    _ZN7Derived3getEv //call get function

Dire simplement, chercher et appeler get(liaison qui s'est passé au moment de la compilation)

pour les non-fonction virtuelle

Base *obj = new Derived();
obj->fun();
pushq   %rbx
subq    $24, %rsp
movl    $8, %edi
call    _Znwm   //call new to allocate memory 
movq    %rax, %rbx
movq    $0, (%rbx)
movq    %rbx, %rdi
call    _ZN7DerivedC1Ev //call constructor
movq    %rbx, -24(%rbp)
movq    -24(%rbp), %rax
movq    (%rax), %rax
movq    (%rax), %rax
movq    -24(%rbp), %rdx
movq    %rdx, %rdi
call    *%rax //call fun

récupérer le vptr, ajoutez la fonction de décalage, de faire appel à la fonction(la liaison qui s'est passé au moment de l'exécution)

Assemblée de 64 est source de confusion, la plupart des programmeurs c++, mais si tout voudrais discuter de alors bienvenue

OriginalL'auteur Ajay yadav