C++ data alignment /member order & inheritance

Naprawdę zadajesz wiele różnych pytań, więc postaram się odpowiedzieć na każde po kolei.

Najpierw chcesz wiedzieć, jak członkowie danych są wyrównane. Wyrównanie członów jest definiowane przez kompilator, ale ze względu na sposób, w jaki Procesory radzą sobie z nieprawidłowymi danymi, wszystkie mają tendencję do podążania za tym samym

Wytyczne, że struktury powinny być wyrównane w oparciu o najbardziej restrykcyjny element (który jest zwykle, ale nie zawsze, największym typem wewnętrznym), a struktury są zawsze wyrównane tak, że wszystkie elementy tablicy są wyrównane tak samo.

Na przykład:

struct some_object
{
    char c;
    double d;
    int i;
};

Ta struktura będzie miała 24 bajty. Ponieważ klasa zawiera podwójne, będzie ona wyrównana o 8 bajtów, co oznacza, że znak będzie wyrównany o 7 bajtów, A int będzie wyrównany o 4, aby zapewnić, że w tablicy some_object wszystkie elementy będą wyrównane o 8 bajtów. Ogólnie rzecz biorąc, jest to zależne od kompilatora, chociaż można zauważyć, że dla danej architektury procesora większość kompilatorów wyrównuje dane to samo.

Druga rzecz, o której wspomniałeś, to pochodne Członkowie klasy. Uporządkowanie i wyrównanie klas pochodnych jest trochę uciążliwe. Klasy indywidualnie postępują zgodnie z zasadami opisanymi powyżej dla struktur, ale kiedy zaczynasz mówić o dziedziczeniu, dostajesz brudną murawę. Podano następujące klasy:

class base
{
    int i;
};

class derived : public base // same for private inheritance
{
    int k;
};

class derived2 : public derived
{
    int l;
};

class derived3 : public derived, public derived2
{
    int m;
};

class derived4 : public virtual base
{
    int n;
};

class derived5 : public virtual base
{
    int o;
};

class derived6 : public derived4, public derived5
{
    int p;
};

Układ pamięci dla bazy będzie następujący:

int i // base

Układ pamięci dla pochodnej będzie:

int i // base
int k // derived

Układ pamięci dla derived2 będzie be:

int i // base
int k // derived
int l // derived2

Układ pamięci dla derived3 będzie następujący:

int i // base
int k // derived
int i // base
int k // derived
int l // derived2
int m // derived3

Można zauważyć, że baza i pochodna pojawiają się tu dwa razy. To jest cud wielokrotnego dziedziczenia.

Aby obejść, że mamy wirtualne dziedzictwo.

Układ pamięci dla derived4 będzie następujący:

base* base_ptr // ptr to base object
int n // derived4
int i // base

Układ pamięci dla derived5 będzie następujący:

base* base_ptr // ptr to base object
int o // derived5
int i // base

Układ pamięci dla derived6 będzie następujący:

base* base_ptr // ptr to base object
int n // derived4
int o // derived5
int i // base

Zauważ, że pochodne 4, 5 i 6 mają wskaźnik do obiektu podstawowego. Jest to konieczne, aby podczas wywoływania którejkolwiek z funkcji bazy miał obiekt do przekazania tym funkcjom. Struktura ta jest zależna od kompilatora, ponieważ nie jest określona w specyfikacji języka, ale prawie wszystkie Kompilatory implementują ją tak samo.

Sprawy stają się bardziej skomplikowane, gdy zaczyna się mówić o funkcjach wirtualnych, ale znowu, większość kompilatorów implementuje je tak samo. Weź udział w następujących zajęciach:

class vbase
{
    virtual void foo() {};
};

class vbase2
{
    virtual void bar() {};
};

class vderived : public vbase
{
    virtual void bar() {};
    virtual void bar2() {};
};

class vderived2 : public vbase, public vbase2
{
};

Każda z tych klas zawiera co najmniej jedną funkcję wirtualną.

Układ pamięci dla vbase będzie następujący:

void* vfptr // vbase

Układ pamięci dla vbase2 będzie następujący:

void* vfptr // vbase2

Układ pamięci dla vderived będzie:

void* vfptr // vderived

Układ pamięci dla vderived2 będzie następujący:

void* vfptr // vbase
void* vfptr // vbase2

Jest wiele rzeczy, których ludzie nie rozumieją, jak działają vftables. Pierwszą rzeczą do zrozumienia jest to, że klasy przechowują tylko wskaźniki do vftables, a nie całe vftables.

Co to oznacza że bez względu na to, ile funkcji wirtualnych posiada klasa, będzie miała tylko jedną funkcję vftable, chyba że dziedziczy ją z innego miejsca poprzez dziedziczenie wielokrotne. Prawie wszystkie Kompilatory umieszczają wskaźnik vftable przed resztą członków klasy. Oznacza to, że możesz mieć pewne wypełnienie między wskaźnikiem vftable a członkami klasy.

Mogę też powiedzieć, że prawie wszystkie Kompilatory implementują możliwości pakietu pragma, które pozwalają ręcznie wymusić strukturę / align = "left" / Generalnie nie chcesz tego robić, chyba że naprawdę wiesz, co robisz, ale to tam jest, a czasami jest konieczne.