Usa el método más simple y fácil de entender para calcular el tamaño de la estructura.

El cálculo de estructuras debe seguir el principio de alineación de bytes.

La alineación de bytes predeterminada de una estructura generalmente cumple tres criterios:

• 1) La dirección inicial de una variable de estructura debe ser divisible por el tamaño de su miembro de tipo básico más ancho;
• 2) El desplazamiento (offset) de cada miembro de la estructura con respecto a la dirección inicial de la estructura es un múltiplo entero del tamaño del miembro. Si es necesario, el compilador agregará bytes de relleno entre los miembros (relleno interno);
• 3) El tamaño total de la estructura es un múltiplo entero del tamaño del miembro de tipo básico más ancho. Si es necesario, el compilador agregará bytes de relleno después del último miembro (relleno final).

En realidad, ignorando estos tres principios por ahora, mi método solo requiere recordar el tercero: el resultado del tamaño de la estructura debe ser un múltiplo entero del byte más grande entre los miembros.

Primero veamos las dos estructuras definidas a continuación:

struct {   char a;   short b;   char c; }S1;

struct {  char  a;  char  b;  short c; }S2;

Se obtiene mediante pruebas con programas respectivamente:sizeof(S1)=6 , sizeof(S2)=4。

Nota: ¿Por qué el resultado es diferente si simplemente se cambia el orden de los miembros de la estructura?

Solución:

• (1) Primero, encuentra el byte más grande entre las variables miembro. Se puede ver que para S1 y S2 el mayor es short, que ocupa 2 bytes;
• (2) Por lo tanto, en adelante se toma como referencia 2 bytes, es decir, como máximo solo se necesitan 2 bytes, el resto es relleno de ocupación. Observa que en la siguiente figura, una celda representa un byte;
• (3) Entonces, primero dibuja 2 celdas; luego, según el orden de los miembros, aumenta gradualmente, tomando siempre 2 como base de incremento.

En el caso de S1, el orden es:char->short->char :

Por lo tanto, para S1 el tamaño de la estructura es 2*3=6. En cuanto a por qué el segundo char no descarta el byte sobrante, es porque se sigue el tercer principio: el resultado del tamaño de la estructura debe ser un múltiplo entero del byte más grande entre los miembros.

S1=2*3=6

En cuanto a S2, también dibujemos un diagrama, pero el orden es:char->char->short：

S2=2*2=4

Siguiendo este método, veamos ahora una estructura como esta:

struct stu1
{
    int i;
    char c;
    int j;
};

Es evidente que el byte más grande es 4. El orden es int, char, int:

Como int ocupa 4, y char ya ha ocupado uno, no es suficiente, por lo que esos tres solo pueden ser espacio de relleno adicional.

Stu1=3*4=12

Entonces, ¿y si cambiamos el orden?

struct stu2
{
    int i;
    int j;
    char  c；
}；

Stu2=3*4=12

Veamos otro caso: cuando un miembro de la estructura es otra estructura, simplemente se suma la estructura miembro como un todo.

typedef struct A
{
    char a1;
    short int a2;
    int a3;
    double d;
};

A=16

typedef struct B
{
    long int b2;
    short int b1;
    A a;
};

Y para B, ignora primero A a; es decir, elimina el miembro A a, calcula la estructura B como 8, por lo que el resultado final es 8+16=24; 24 es el resultado final.

Dirección original: https://www.cnblogs.com/lykbk/archive/2013/04/02/krtmbhrkhoirtj9468945.html