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!

//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.

+---------------+     +-->  +---------------+ <--+
|     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.

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