Mam wirtualne pytania dotyczące rozmiaru obiektu.

1) funkcja wirtualna

class A {
    public:
       int a;
       virtual void v();
    }

Rozmiar klasy A to 8 bajtów .... jedna liczba całkowita (4 bajty) plus jeden wirtualny wskaźnik (4 bajty) Jest to jasne!

class B: public A{
    public:
       int b;
       virtual void w();
}

Jaka jest wielkość klasy B? Testowałem przy użyciu rozmiaru B, drukuje 12

Czy to oznacza, że ​​jest tylko jeden vptr, nawet zarówno klasa B, jak i klasa A mają funkcję wirtualną? Dlaczego jest tylko jeden vptr?

class A {
public:
    int a;
    virtual void v();
};

class B {
public:
    int b;
    virtual void w();
};

class C :  public A, public B {
public:
    int c;
    virtual void x();
};

Rozmiar C to 20 ........

Wydaje się, że w tym przypadku dwa układy są w układzie ..... Jak to się dzieje? Myślę, że dwa vptrs jeden jest dla klasy A, a drugi dla klasy B .... więc nie ma vptr dla wirtualnej funkcji klasy C?

Moje pytanie brzmi: jaka jest zasada dotycząca liczby osób w spadku?

2) dziedziczenie wirtualne

    class A {
    public:
        int a;
        virtual void v();
    };

    class B: virtual public A{                  //virtual inheritance 
    public:
        int b;
        virtual void w();
    };

    class C :  public A {                      //non-virtual inheritance
    public:
        int c;
        virtual void x();
    };

class D: public B, public C {
public:
    int d;
    virtual void y();
};

Wielkość A wynosi 8 bajtów -------------- 4 (int a) + 4 (vptr) = 8

Rozmiar B to 16 bajtów -------------- Bez wirtualnego powinien wynosić 4 + 4 + 4 = 12. Dlaczego są tu kolejne 4 bajty? Jaki jest układ klasy B?

Rozmiar C to 12 bajtów. -------------- 4 + 4 + 4 = 12. To jasne!

Rozmiar D to 32 bajty -------------- powinien wynosić 16 (klasa B) + 12 (klasa C) + 4 (int d) = 32. Czy to prawda?

    class A {
    public:
        int a;
        virtual void v();
    };

    class B: virtual public A{                       //virtual inheritance here
    public:
        int b;
        virtual void w();
    };

    class C :  virtual public A {                    //virtual inheritance here
    public:
        int c;
        virtual void x();
    };

  class D: public B, public C {
   public:
        int d;
        virtual void y();
    };

sizeof A to 8

rozmiar B to 16

rozmiar C to 16

rozmiar D to 28 Czy to oznacza 28 = 16 (klasa B) + 16 (klasa C) - 8 (klasa A) + 4 (co to jest?)

Moje pytanie brzmi: dlaczego jest dodatkowe miejsce, gdy stosowane jest wirtualne dziedziczenie?

Jaka jest reguła poniżej wielkości obiektu w tym przypadku?

Jaka jest różnica, gdy wirtualny jest stosowany na wszystkich klasach bazowych i na części klas podstawowych?