Tamaño de la estructura en C/ C++

Tamaño de la estructura en C/ C++

En este artículo, hemos explicado cómo calcular el tamaño de memoria de una estructura en lenguaje de programación C y C++ . Para encontrar el tamaño real, debe comprender dos conceptos de relleno y empaque. El tamaño no es la suma de los elementos individuales, así que sigue leyendo.

Tabla de contenidos:

  1. Relleno de estructura
  2. Estructura de embalaje

Exploremos las ideas con ejemplos de código y explicaciones.

Relleno de estructura

La estructura de las tiendas informáticas se basa en el concepto de límite de palabras.
El tamaño de un límite de palabra depende de la máquina. En una computadora con un límite de palabra de dos bytes, los miembros de una estructura se almacenan alineados a la izquierda en el límite de palabra.

El procesador no lee 1 byte a la vez de la memoria. Lee 1 palabra a la vez.
En un procesador de 32 bits, puede acceder a 4 bytes a la vez, lo que significa que el tamaño de la palabra es de 4 bytes.
De manera similar, en un procesador de 64 bits, puede acceder a 8 bytes a la vez, lo que significa que el tamaño de la palabra es de 8 bytes.

Lo que sabemos es que el tamaño de una estructura es la suma de todos los miembros de datos. Me gusta para la siguiente estructura,

struct A{
    int n1;
    int* n2;
    char c1;
    char *c2;
};

El tamaño de la estructura debe ser la suma de todos los miembros de datos, que es:Tamaño de int n1+ tamaño de int* n2 + tamaño de char c1+ tamaño de char* c2

Ahora considerando el sistema de 64 bits,
El tamaño de int es de 4 bytes
El tamaño del carácter es de 1 byte
El tamaño de cualquier tipo de puntero es de 8 bytes
(El tamaño del puntero tampoco depende del tipo de datos al que apuntan)

Entonces el tamaño de la estructura debe ser:(4+8+1+8)=21 Bytes

Veamos qué está dando el compilador usando el operador sizeof().

#include <stdio.h>

struct ABC {
    int n1;
    int* n2;
    char c1;
    char* c2;
};

int main()
{
    struct ABC a;
    printf("Size of struct ABC: %lu\n", sizeof(struct ABC));
    printf("Size of object a: %lu\n", sizeof(a));
    return 0;
}

La salida del programa anterior es:
Tamaño de la estructura ABC:32
Tamaño del objeto a:32

Parece que el compilador tomó el tamaño máximo del tipo de datos y asignó la misma memoria a todos los tipos de datos.
Se alinea hasta el límite de la memoria máxima asignada. Aquí encontramos que la memoria máxima asignada es de 8 bytes, por lo que todos los miembros de datos adquieren 8 bytes y el tamaño total es de 32 bytes.

¿Es como el número de miembros de datos * tamaño máximo de tipo de datos?
La respuesta es no. Verifique la siguiente estructura que tiene los mismos miembros pero el orden es diferente.

struct B{
    int* b;
    char c;
    int a;
    char *d;
};

Considere este ejemplo de código C:

#include <stdio.h>

struct BAC {
    int* n2;
    char c1;
    int n1;
    char* c2;
};

int main()
{
    struct BAC b;
    printf("Size of struct BAC: %lu\n", sizeof(struct BAC));
    printf("Size of object b: %lu\n", sizeof(b));
    return 0;
}

La salida del programa anterior es:
Tamaño de la estructura BAC:24
Tamaño del objeto b:24

El compilador sigue alineándose con avidez y es por eso que alineó char c &int a en la misma fila. Cuando intentó alinear char* d, no pudo ya que solo quedaban 3 bytes. Pero en lugar de char*, si fuera solo char, entonces se habría alineado en la misma línea.

Cuando declaramos variables de estructura, cada una de ellas puede contener bytes de holgura y los valores almacenados en dichos bytes de holgura no están definidos. Debido a esto, incluso si los miembros de dos variables son iguales, sus estructuras no necesariamente son iguales.

C por lo tanto, no permite la comparación de estructuras.

Estructura de embalaje

Podemos evitar el desperdicio de memoria simplemente escribiendo #pragma pack(1)

#pragma pack(1)

#pragma

#pragma es una directiva de propósito especial que se utiliza para activar o desactivar ciertas funciones.

#include <stdio.h>
#pragma pack(1)
struct ABC {
    char a;
    int b;
    char c;
};

int main()
{
    printf("Size of struct ABC: %lu\n", sizeof(struct ABC));
    return 0;
}

La salida del programa anterior es:
Tamaño de la estructura ABC:6
Como int tomará 4 bytes y la variable de dos caracteres tomará 1 byte cada una.

Ahora veamos algunas preguntas relacionadas con este tema.

Pregunta 1

¿Qué directiva se usa para empaquetar estructuras?

#pragma pack(1)#program pack(1)#pragma set(1)Ninguno de estos Usamos #pragma pack(1) para evitar el desperdicio de memoria.
struct BAC {
    char c;
    int n;
    char b;
};

Pregunta 2

¿Cuál es el tamaño de la estructura anterior?

128610 Como aquí se aplicará relleno de estructura, el tamaño es de 12 bytes.

Con este artículo en OpenGenus, debes tener la idea completa de cómo calcular el tamaño de la estructura (struct) en C y C++.