alineación de datos de c++ / orden de miembros y herencia

Realmente estás haciendo muchas preguntas diferentes aquí, así que voy a hacer mi mejor esfuerzo para responder cada una a su vez.

Primero desea saber cómo se alinean los miembros de datos. La alineación de miembros está definida por el compilador, pero debido a cómo las CPU tratan los datos desalineados, todos tienden a seguir la misma

Directriz de que las estructuras deben alinearse en función del miembro más restrictivo (que generalmente, pero no siempre, es el tipo intrínseco más grande), y las estructuras siempre son alineado de tal manera que los elementos de una matriz están todos alineados de la misma manera.

Por ejemplo:

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

Esta estructura sería de 24 bytes. Debido a que la clase contiene un doble, estará alineada con 8 bytes, lo que significa que el char será rellenado con 7 bytes, y el int será rellenado con 4 para asegurar que en un array de some_object, todos los elementos estarán alineados con 8 bytes. En términos generales, esto depende del compilador, aunque encontrará que para una arquitectura de procesador dada, la mayoría de los compiladores alinean los datos lo mismo.

Lo segundo que mencionas son los miembros derivados de la clase. Ordenar y alinear las clases derivadas es un poco molesto. Las clases individualmente siguen las reglas que describí anteriormente para las estructuras, pero cuando empiezas a hablar de herencia te metes en un terreno desordenado. Dadas las siguientes clases:

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;
};

El diseño de memoria para base sería:

int i // base

El diseño de memoria para derived sería:

int i // base
int k // derived

El diseño de memoria para derived2 sería be:

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

El diseño de memoria para derived3 sería:

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

Puede notar que base y derivada aparecen dos veces aquí. Esa es la maravilla de la herencia múltiple.

Para sortear que tenemos herencia virtual.

El diseño de memoria para derived4 sería:

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

El diseño de memoria para derived5 sería:

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

El diseño de memoria para derived6 sería:

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

Usted notará que 4, 5, y 6 derivados todos tienen un puntero al objeto base. Esto es necissary por lo que cuando se llama a cualquiera de las funciones de base tiene un objeto para pasar a esas funciones. Esta estructura depende del compilador porque no está especificada en la especificación del lenguaje, pero casi todos los compiladores la implementan de la misma manera.

Las cosas se complican cuando se empieza a hablar de funciones virtuales, pero de nuevo, la mayoría de los compiladores las implementan de la misma manera. Tome las siguientes clases:

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
{
};

Cada una de estas clases contiene al menos una función virtual.

El diseño de memoria para vbase sería:

void* vfptr // vbase

El diseño de memoria para vbase2 sería:

void* vfptr // vbase2

El diseño de memoria para vderived sería:

void* vfptr // vderived

El diseño de memoria para vderived2 sería:

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

Hay muchas cosas que la gente no entiende sobre cómo funcionan las vftables. Lo primero que hay que entender es que las clases solo almacenan punteros a vftables, no vftables completos.

Lo que eso significa es que no importa cuántas funciones virtuales tenga una clase, solo tendrá una vftable, a menos que herede una vftable de otro lugar a través de herencia múltiple. Casi todos los compiladores ponen el puntero vftable antes que el resto de los miembros de la clase. Eso significa que puede tener algún relleno entre el puntero vftable y los miembros de la clase.

También puedo decirle que casi todos los compiladores implementan las capacidades del paquete pragma que le permiten forzar manualmente la estructura alineacion. Generalmente no quieres hacer eso a menos que realmente sepas lo que estás haciendo, pero está ahí, y a veces es necesario.

Lo último que preguntó es si puede controlar el pedido. Siempre controlas los pedidos. El compilador siempre ordenará las cosas en el orden en que las escriba. Espero que esta larga explicación llegue a todo lo que necesitas saber.