Warum überlappt sich der Speicher für eine doppelte leere Basis nicht mit einem vtable-Zeiger?

Betrachten Sie dieses Beispiel:

#include <iostream>

int main()
{
    struct A {};
    struct B : A {};
    struct C : A, B {};

    std::cout << sizeof(A) << '\n'; // 1
    std::cout << sizeof(B) << '\n'; // 1
    std::cout << sizeof(C) << '\n'; // 2, because of a duplicate base

    struct E : A {virtual ~E() {}};
    struct F : A, B {virtual ~F() {}};

    std::cout << sizeof(E) << '\n'; // 8, the base overlaps the vtable pointer
    std::cout << sizeof(F) << '\n'; // 16, but why?
}

^{(renn auf Godbolt)}

Hier können Sie sehen, dass für struct Edie leere Basisklasse (die 1 Byte groß ist) erwartungsgemäß derselbe Speicher wie für den vtable-Zeiger verwendet wird.

Aber für struct F, die eine doppelte leere Basis hat, passiert dies nicht. Was verursacht das?

Ich erhalte das gleiche Ergebnis bei GCC, Clang und MSVC. Die obigen Ergebnisse gelten für x64 sizeof(void *) == 8.

Interessanterweise führen struct G : A, B {void *ptr;};GCC und Clang EBO durch (die Größe ist 8), MSVC jedoch nicht (die Größe ist 16).

Weil der Compiler nach Struktur A ein Byte-Padding hinzufügt

F {vptr (8) + 0 Mitglieder von A + 1 Auffüllen (weil A leer ist) +0 von b} = 9, dann fügt der Compiler 7 Byte Auffüllen hinzu, um den Speicher der Struktur auszurichten;

E {vptr (8) + 0 Mitglieder für A} = 8 Keine Auffüllung erforderlich

von Microsoft

Jedes Datenobjekt hat eine Ausrichtungsanforderung. Für Strukturen ist die Anforderung die größte ihrer Mitglieder. Jedem Objekt wird ein Versatz zugewiesen, sodass der Versatz% Ausrichtungsanforderung == 0 ist

https://docs.microsoft.com/en-us/cpp/c-language/storage-and-alignment-of-structures?view=vs-2019

BEARBEITEN:

Hier ist meine Demo:

int main()
{
    C c;
    A* a = &c;
    B* b = &c;

    std::cout << sizeof(A) << " " << a << '\n'; 
    std::cout << sizeof(B) << " " << b << '\n'; 
    std::cout << sizeof(C) << " " << &c << '\n'; 

    E e;
    a = &e;
    std::cout << sizeof(E) <<" " << &e << " " << a << '\n'; 

    F f;
    a = &f;
    b = &f;
    std::cout << sizeof(F) << " " << &f << " " << a << " " << b << '\n';

}

Ausgabe:

1 0000007A45B7FBB4
1 0000007A45B7FBB5
1 0000007A45B7FBB4
8 0000007A45B7FC18 0000007A45B7FC20
16 0000007A45B7FC38 0000007A45B7FC40 0000007A45B7FC41

Wie Sie sehen können, überschneiden sich a & b nie miteinander und mit vptr bei Mehrfachvererbung hat jeder seinen eigenen Zeigerwert

Anmerkung kompiliert von VC2019 x64 Build