Virtuelle Tabellen und virtuellen Zeiger für mehrere virtuelle Vererbung und Typumwandlung

Folgendes gilt für den GCC, aber kann auch wahr sein, damit der compiler Sie verwenden. All dies ist von der Implementierung abhängig, und unterliegen daher nicht der C++ - standard. Jedoch, GCC schreiben Sie Ihre eigene binäre standard-Dokument, Itanium ABI.

Ich versuchte zu erklären, grundlegende Konzepte wie virtuelle Tabellen angelegt werden, in mehr einfachen Worten, wie ein Teil meiner Artikel über virtuelle Funktion performance in C++, die Sie nützlich finden können. Hier erhalten Sie Antworten auf Ihre Fragen:

1. Einen richtigeren Weg zu zeigen interne Darstellung des Objekts:

   | vptr | ======= | ======= |  <-- your object
          |----A----|         |
          |---------B---------|

   B enthält seiner Basis-Klasse A, es fügt nur ein paar seiner eigenen Mitglieder nach deren Ende.

   Casting von B* zu A* ja, macht nichts, es gibt die gleichen Zeiger und die vptr bleibt die gleiche. Aber, in einer nussschale, virtuelle Funktionen sind nicht immer genannt, über die vtable. Manchmal nennt man Sie, genau wie die anderen Funktionen.

   Hier finden Sie weitere ausführliche Erklärung. Sollten Sie unterscheiden zwei Möglichkeiten der Aufruf member-Funktion:

   A a, *aptr;
   a.func();         //the call to A::func() is precompiled!
   aptr->A::func();  //ditto
   aptr->func();     //calls virtual function through vtable.
                     //It may be a call to A::func() or B::func().

   Die Sache ist die, dass es bekannt zur compile-Zeit, wie die Funktion aufgerufen werden: über vtable-oder einfach nur ein üblichen call. Und die Sache ist, dass der Art einer casting-Ausdruck zur Kompilierzeit bekannt ist, und damit der compiler wählt die richtige Funktion zur compile-Zeit.

   B b, *bptr;          
   static_cast<A>(b)::func(); //calls A::func, because the type
      //of static_cast<A>(b) is A!

   Es gar nicht von innen sehen vtable in diesem Fall!

2. In der Regel, Nein. Eine Klasse kann mehrere vtables wenn es erbt von mehreren Basen, die jeweils eigene vtable. Solche virtuellen Tabellen bildet eine "virtuelle Tabelle-Gruppe" (siehe pt. 3).

   Klasse muss auch eine Reihe von Bau-vtables, richtig distpatch virtuelle Funktionen beim Aufbau von Grundlagen für ein Komplexes Objekt. Lesen Sie weiter in die standard-I verbunden.

3. Hier ist ein Beispiel. Übernehmen C erbt von A und B jede Klasse definieren virtual void func() sowie a,b oder c virtuelle Funktion relevant sein name.

   Den C wird eine vtable Gruppe von zwei vtables. Es wird in teilen eine vtable mit A (die vtable, wo die eigenen Funktionen der aktuellen Klasse gehen wird als "primäre"), und eine vtable für B werden angefügt:

   | C::func()   |   a()  |  c()  || C::func()  |   b()   |
   |---- vtable for A ----|        |---- vtable for B ----| 
   |--- "primary virtual table" --||- "secondary vtable" -|
   |-------------- virtual table group for C -------------|

   Die Darstellung der Objekt im Speicher Aussehen wird fast der gleichen Weise Ihr vtable sieht. Fügen Sie einfach ein vptr vor jeder vtable in einer Gruppe, und Sie haben eine grobe Schätzung, wie die Daten angelegt werden, innerhalb des Objekts. Sie können darüber Lesen Sie in der relevante Abschnitt der GCC Binär-standard.

4. Virtuellen Basen (einige von Ihnen) angelegt werden, am Ende der vtable-Gruppe. Dies geschieht, weil jede Klasse sollte nur eine virtuelle Basis, und wenn Sie waren vermischt mit den "üblichen" vtables, dann compiler konnte nicht re-Teile gebaut vtables zu machen, diejenigen, die von abgeleiteten Klassen. Dies würde dazu führen, computing unnötig, die Abstände und die Leistung verringern würde.

   Durch solch eine Platzierung, virtual Grundlagen auch eine Einführung in Ihre vtables zusätzliche Elemente: vcall offset (Adresse für den final overrider beim springen aus dem Zeiger auf eine virtuelle Basisklasse innerhalb eines vollständigen Objekts an den Anfang der Klasse, überschreibt die virtuelle Funktion) für jede virtuelle Funktion definiert. Auch die einzelnen virtuellen Basis fügt vbase offsets, die eingefügt werden, vtable von der abgeleiteten Klasse enthalten; Sie lassen, um herauszufinden, wo die Daten der virtuellen Basis beginnen (es kann nicht kompiliert werden, da die tatsächliche Adresse hängt von der Hierarchie: virtuelle Basen werden am Ende des Objekts, und die Verschiebung von Anfang variiert je nachdem, wie viele nicht-virtuelle Klassen die aktuelle Klasse erbt.).

Wuff, ich hoffe, ich habe nicht vorstellen, viel unnötige Komplexität. In jedem Fall finden Sie der ursprünglichen standard, oder zu einem beliebigen Dokument eigene compiler.

InformationsquelleAutor P Shved

1. Wenn Objekt B erbt von A und dann die Speicher-Darstellung für B wird folgende sein:

   • Zeiger auf die virtuelle Tabelle von A
   • Einer bestimmten Variablen/Funktionen
   • Zeiger auf die virtuelle Tabelle der B
   • B bestimmte Variablen/Funktionen/überschreibt

   Wenn Sie B* b = new B(); (A)b->f (), dann:

   • wenn f wurde erklärt, wie eine virtuelle Funktion wird dann die B-Implementierung wird aufgerufen, da b vom Typ B
   • wenn f wurde nicht erklärt, wie eine virtuelle Funktion wird dann aufgerufen, wenn es keine lookup in er vtable für die korrekte Umsetzung und Implementierung aufgerufen werden.

2. Jedes Objekt hat seine eigene vtable (nehmen Sie das nicht für selbstverständlich, wie ich haben, um es zu erforschen

3. Werfen Sie einen Blick auf diese ein Beispiel für die vtable-layour beim Umgang mit mehrfacher Vererbung

4. Sehen diese für eine Diskussion über die diamond Vererbung und der vtable-Darstellung

InformationsquelleAutor Ando