Unterschied zwischen dem Aufruf der virtuellen Funktion und nicht-virtuelle Funktion?

Obwohl virtualism/dynamic dispatch ist streng Umsetzung definiert, die meisten(Lesen alle bekannten -) Compiler implementieren Sie mithilfe vptr und vtable.

Gesagt, dass der Unterschied zwischen dem Aufruf einer nicht-virtuellen Funktion und virtuelle Funktion ist:

Nicht-virtuelle Funktionen gelöst statically bei Compile-time, Während Virtuelle Funktionen gelöst dynamically bei Run-time.

Um diese Flexibilität zu erreichen, in der Lage zu entscheiden, welche Funktion aufgerufen wird, zur Laufzeit,
es ist ein wenig Aufwand, im Falle von virtuellen Funktionen.

Einen zusätzlichen fetch nennen, die durchgeführt werden muss, und es ist den Aufwand/Preis, den Sie zahlen für die Verwendung von dynamic dispatch.

Im Falle einer nicht-virtuellen Funktion die Reihenfolge der Aufrufe ist:

fetch-call

Muss der compiler fetch Adresse der Funktion und dann call es.

Während im Fall von virtuellen Funktionen, die Reihenfolge ist:

fetch-fetch-call

Muss der compiler fetch die vptr von der this, dann fetch die Adresse der Funktion aus der vptr und dann call die Funktion.

Dies ist nur eine vereinfachte Erklärung der tatsächlichen Reihenfolge vielleicht weit komplexer als das, aber das ist, was Sie wirklich brauchen, zu wissen, Man muss nicht wirklich wissen müssen, um die Umsetzung nitty gritty ist.

Gut Zu Lesen:

Vererbung & Virtuelle Funktionen

Beim Aufruf einer virtuellen Methode, es zu schauen, welche Funktion aufgerufen wird, in eine virtuelle Funktionstabelle.

Nicht-virtuelle member-Funktionen gelöst sind statisch. member-Funktion sind Bindung statisch zur compile-Zeit basierend auf dem Typ der pointer (oder Referenz) auf das Objekt.

Im Gegensatz dazu virtuelle member-Funktionen sind Bindung zur Laufzeit dynamisch. Wenn die Klasse mindestens eine virtuelle Memberfunktion dann compiler legt eine versteckte Zeiger in das Objekt, genannt vptr(virtual address-Tabelle) während der Konstruktion des Objekts.

Den compiler erstellt eine v-table für jede Klasse, die mindestens eine virtuelle Funktion. Virtuelle Tabelle enthalten virtuelle Funktion Adresse. Es kann ein array oder eine Liste(abhängig von der compiler des virtuellen Funktionszeiger s

Bei einem Versand an eine virtuelle Funktion, die run-time-system folgt dem Objekt, die v-Zeiger(Holen der Adresse aus dem class-Objekt) der Klasse v-Tabelle-offset Hinzugefügt, um die Basis-Adresse(vptr) und die Funktion aufrufen.

Den Raum-Kosten Aufwand die oben genannten Technik ist nominal: eine zusätzliche Zeiger pro Objekt (aber nur für Objekte, die Notwendigkeit, dynamische Bindung), plus eine zusätzliche Zeiger pro Methode (aber nur für virtuelle Methoden).
Die Zeit-Kosten - Aufwand ist auch ziemlich nominal: im Vergleich zu einer normalen Funktion aufrufen, einen virtuellen Funktionsaufruf erfordert zwei zusätzliche holt (um den Wert der v-Zeiger, eine zweite, um die Adresse der Methode).

Keiner dieser runtime-Aktivität geschieht mit nicht-virtuelle Funktionen, da der compiler löst den nicht-virtuelle Funktionen, die ausschließlich zur compile-Zeit basierend auf dem Typ des Zeigers.

Habe ich genommen einfaches Beispiel zu verstehen, in der besser Art und Weise, wie die Bindung geschah für nicht-virtuelle Funktion & virtuelle Funktion und wie virtual-function-Mechanismus funktioniert.

#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();
}

, Wie die vtable erstellt für Base & abgeleitete Klasse

Assembler-code, der generiert wird, zum besseren Verständnis.

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

Ich abgerufen haben, die Informationen der vtable von virtuellen.s für die Basis-und Abgeleitete Klasse jeweils:

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

Wie Sie sehen können, Spaß & fun1 sind nur zwei virtuellen Funktionen in der Basisklasse. Vtable der Basisklasse(_ZTV4Base) Einträge, die von beiden virtuellen Funktionen. Vtable nicht über Eintritt von nicht-virtuellen Funktion. Bitte nicht verwechseln mit dem Namen des Spaßes(ZN4Base3funEv) & fun1(ZN4Base4fun1Ev), Ihren Namen bekam entstellt.

Abgeleitete Klasse vtable haben Baum-Einträge

1. Spaß(_ZN7Derived3funEv) override-Funktion
2. fun1(_ZN4Base4fun1Ev) von Basisklasse geerbt
3. fun3(_ZN7Derived4fun3Ev) neue Funktion in der abgeleiteten Klasse

Wie nicht-virtuelle Funktion & virtuelle Funktion aufgerufen?

für nicht-virtuelle Funktion

    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

Einfach sagen, Holen und Aufruf get(binding geschah zur compile-Zeit)

für nicht-virtuelle Funktion

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

Holen vptr, fügen Sie die Funktion offset, rufen Sie die Funktion(verbindliche passiert zur Laufzeit)

Montage von 64 ist verwirrend, die meisten c++ - Programmierer, aber wenn alle diskutieren wollen, willkommen