Tamaño de la estructura con un char, un doble, un int y al

Question

Cuando corro sólo el fragmento de código

int *t; 
std::cout << sizeof(char) << std::endl; 
std::cout << sizeof(double) << std::endl; 
std::cout << sizeof(int) << std::endl; 
std::cout << sizeof(t)  << std::endl; 

me da un resultado como este:

1 
8 
4 
4 

Total: 17.

Pero cuando pruebo sizeof struct que contiene estos tipos de datos me da 24, y estoy confundido. ¿Cuáles son los 7 bytes adicionales?

Este es el código

#include <iostream> 
#include <stdio.h> 
struct struct_type{ 
    int i; 
    char ch; 
    int *p; 
    double d; 
} s; 

int main(){ 
    int *t; 
    //std::cout << sizeof(char) <<std::endl; 
    //std::cout << sizeof(double) <<std::endl; 
    //std::cout << sizeof(int) <<std::endl; 
    //std::cout << sizeof(t)  <<std::endl; 

    printf("s_type is %d byes long",sizeof(struct struct_type)); 

    return 0; 
} 

: editar

He actualizado mi código como este

#include <iostream> 
#include <stdio.h> 
struct struct_type{ 
    double d_attribute; 
    int i__attribute__(int(packed)); 
    int * p__attribute_(int(packed));; 
    char ch; 
} s; 

int main(){ 
    int *t; 
    //std::cout<<sizeof(char)<<std::endl; 
    //std::cout<<sizeof(double)<<std::endl; 
    //std::cout<<sizeof(int)<<std::endl; 
    //std::cout<<sizeof(t)<<std::endl; 

    printf("s_type is %d bytes long",sizeof(s)); 

    return 0; 
} 

y ahora me muestra 16 bytes. ¿Es bueno o he perdido algunos bytes importantes?

Answer 1

Hay algunos bytes no utilizados entre algunos miembros a keep the alignments correct. Por ejemplo, un puntero por defecto reside en límites de 4 bytes para la eficiencia, es decir, su dirección debe ser un múltiplo de 4. Si la estructura contiene sólo un char y un puntero

struct { 
    char a; 
    void* b; 
}; 

continuación b no se puede utilizar el adderss # 1 - debe colocarse en el n. ° 4.

0 1 2 3 4 5 6 7 
+---+- - - - - -+---------------+ 
| a | (unused) | b    | 
+---+- - - - - -+---------------+ 

En su caso, el extra de 7 bytes proviene de 3 bytes por la alineación del int*, y 4 bytes por la alineación del double.

0 1 2 3 4 5 6 7 8 9 a b c d e f 
+---------------+---+- - - - - -+---------------+- - - - - - - -+ 
| i    |ch |   | p    |    | 
+---------------+---+- - - - - -+---------------+- - - - - - - -+ 
10 11 12 13 14 15 16 17 
+-------------------------------+ 
| d        | 
+-------------------------------+ 

Answer 2

... me da 24, y estoy confundido. ¿Cuáles son los 7 bytes adicionales?

Estos son los bytes de relleno insertados por el compilador. El relleno de la estructura de datos depende de la implementación.

De Wikipedia, Data structure alignment:

alineación de datos significa poner los datos a un desplazamiento igual a un múltiplo del tamaño de la palabra, lo que aumenta el rendimiento del sistema de memoria debido a la forma en que la CPU se encarga de la memoria. Para align datos, puede ser necesario insertar algunos bytes sin sentido entre el final de la última estructura de datos y el inicio de la siguiente, que es el relleno de la estructura de datos.

Answer 3

El compilador puede alinear los miembros de la estructura con las direcciones para un acceso más rápido. p.ej. Límites de 32 bits. El estándar solo exige que los miembros del objeto se almacenen en el orden en que se declaran. Así que siempre asegúrese de usar sizeof y offsetof cuando necesite una posición exacta en la memoria.

Answer 4

Ver comp.lang.c FAQ list · Question 2.12:

¿Por qué mi compilador dejando agujeros en las estructuras, perder el espacio y la prevención de `` binario '' de E/S de archivos de datos externos? ¿Puedo desactivarlo o controlar la alineación de los campos de estructura?

Answer 5

El tamaño adicional proviene de la alineación de datos, es decir, los miembros están alineados a múltiplos de 4 u 8 bytes.

Tu compilador probablemente alinea int y punteros a múltiplos para 4 bytes y el doble a múltiplos para 8 bytes.

Si mueve el doble a una posición diferente dentro de la estructura, es posible que pueda reducir el tamaño de la estructura de 24 a 20 bytes. Pero depende del compilador.

Answer 6

También a veces se necesita la estructura para mantener el orden que requería. En estos casos, si está utilizando gcc, debe usar la instrucción __attribute__((packed)).

See also this para obtener más información.

Answer 7

Tiene 24 bytes debido al relleno. La mayoría de los compiladores rellenan los datos a un múltiplo de su tamaño. Por lo tanto, una int 4-byte se rellena a un múltiplo de 4 bytes. Un doble de 8 bytes está acolchado a un múltiplo de 8 bytes. Por su estructura, esto significa:

struct struct_type{ 
    int i; // offset 0 (0*4) 
    char ch; // offset 4 (4*1) 
    char padding1[3]; 
    int *p; // offset 8 (2*4) 
    char padding1[4]; 
    double d; // offset 16 (2*8) 
}s; 

Usted puede optimizar su estructura como esa:

struct struct_type{ 
    double d; 
    int i; 
    int *p; 
    char ch; 
}s; 

sizeof (s) == 17 en la mayoría de los compiladores (20 en algunos otros)

Answer 8

$ 9.2/12 estados: "Los miembros de datos no estáticos de una clase (no sindicalizada) declarados sin un intermediario de acceso intermedio se asignan para que los miembros posteriores tengan direcciones más altas dentro de un objeto de clase. -specificador no especificado (1 1.1). Los requisitos de alineación de implementación pueden causar que dos miembros adyacentes no se asignen inmediatamente uno después del otro; entonces podría requisitos de espacio para la administración de funciones virtuales (10.3) y clases base virtuales (10.1). "

Así que al igual que el sizeof (doble) y sizeof (int), los desplazamientos a los que se alinearían los miembros de la estructura sin especificar, excepto que los miembros que se declaran posteriormente están en direcciones superiores.

Answer 9

Para ampliar ligeramente la excelente respuesta de KennyDM (Kenny, roba esto para complementar tu respuesta si quieres), esta es probablemente la estructura de tu memoria una vez que el compilador ha alineado todas las variables:

0 1 2 3 4 5 6 7 
+-------------------+----+-----------+ 
| i     | ch | (unused) | 
+-------------------+----+-----------+ 

    8 9 10 11 12 13 14 15 
+-------------------+----------------+ 
| p     | (unused)  | 
+-------------------+----------------+ 

16 17 18 19 20 21 22 23 
+------------------------------------+ 
| d         | 
+------------------------------------+ 

Entonces, debido a la brecha de 3 bytes entre "ch" y "p", y la brecha de 4 bytes entre "p" y "d", obtienes un relleno de 7 bytes para tu estructura, por lo tanto, el tamaño de 24 bytes. Como el double de su entorno tiene una alineación de 8 bytes (es decir, debe residir en su propio bloque de 8 bytes, como puede ver arriba), el total struct también estará alineado en 8 bytes, por lo que incluso se reordenará las variables no alterarán el tamaño desde 24 bytes.