Virtual Table (vtbl) der Aufbau?

DeepCopy

Wie ist der schematische Aufbau von der Virtual Table zu verstehen?

Beispiel:

class X
{
  private:
    int i;
  public:
    virtual void push();
    virtual void pop();
    virtual void delete();
};

class Y : public X
{
  private:
   int j;
   virtual void push();
   virtual void pop();
};

int main()
{
  X x;
  Y y;
  return 0;
}

folglich existieren 2! Virtual Table eines für Objekte der Klasse X und eines für Objekte der Klasse Y. Richtig?

Die Virtuellen Tabellen werden dann so aussehen?

+---------------+     +-->  +---------------+ <--+
|     obj x     |     |     |  vtbl    X    |    |
+---------------+     |     +---------------+    | 
|     vtptr     ------+     |ptrBasis: NULL |    |
+---------------+           +---------------+    |
|     int i     |           |  X::push()    |    |
+---------------+           |  X::push()    |    |
                            |  X::delete()  |    |
                            +---------------+    | 
                                                 |
+---------------+     +-->  +---------------+    |
|     obj y     |     |     |  vtbl    Y    |    | 
+---------------+     |     +---------------+    |
|     vtptr     ------+     |ptrBasis: zeigt ---–+
+---------------+           +---------------+
|     int j     |           |  Y::push()    |
+---------------+           |  Y::push()    |
                            |  Y::delete()? |
                            +---------------+

Ich nehme mal an:

Die Pointer ptrBasis lassen sich bei Mehrfachvererbung bel. erweitern
Bei weiteren Klassen wird einfach die Liste erweitert
Alle virtuellen Funktionen werden bei jeder Virtuellen Tabelle nochmals angegeben

Ich hoffe ich habe jetzt keinen riesen Bock geschossen!

otze

Frag den Hersteller deines Compilers. Es muss nicht einmal vtables geben. Warum sollte dann irgendein schematischer Aufbau richtig oder falsch sein?

//edit ich will mal nicht so sein:
http://de.wikipedia.org/wiki/Tabelle_virtueller_Methoden

Wie das genau implementiert ist, kann dir aber niemand sagen, außer die Compilerhersteller.

DeepCopy

Also hier liegt der Hund begraben!

+---------------+     +-->  +---------------+ <--+
|     obj x     |     |     |  vtbl    X    |    |
+---------------+     |     +---------------+    |
|     vtptr     ------+     |ptrBasis: NULL |    |
+---------------+           +---------------+    |
|     int i     |           |  X::push()    |    |
+---------------+           |  X::push()    |    |
                            |  X::delete()  |    |
                            +---------------+    |
                                                 |
+---------------+     +-->  +---------------+    |
|     obj y     |     |     |  vtbl    Y    |    |
+---------------+     |     +---------------+    |
|     vtptr     ------+     |ptrBasis: zeigt ---–+
+---------------+           +---------------+
|     int j     |           |  Y::push()    |
+---------------+           |  Y::push()    |
                            |  X::delete()  |  <-- muss X::delete()
                            +---------------+

Den Rest habe ich mir dann wohl selbst richtig zusammengereimt, danke!

Damit wird, was ich schon befürchtet, die gesamte Klassendeklaration von virtuelle Elementfunktionen mitgeschleppt. D.h. gibt es in anderen Sprachen wzb. Pascal auch das Konzept von dynamic und virtual getrennt um diesen Overhead zu vermeiden.

otze

otze schrieb:

Wie das genau implementiert ist, kann dir aber niemand sagen, außer die Compilerhersteller.

helferlein

was soll daran overhead sein? jede (normale) klasse hat einen zeiger mehr.
lässt sich eh nicht vermeiden. das einzige was größer ist, ist die tabelle pro
klasse. die paar bytes. wieviele klassen hast du höchstens? 100. wieviele methoden
pro klasse? 20? 8kb an tabellen. gaaaaaaanz mies. das layout ist schon ok, da
du in konstanter zeit auf eine methode zu greifen kannst (bei normalen klassen)