Uniones en C explicadas: Gestión eficiente de memoria para múltiples tipos de datos

Una unión (union) es un tipo de dato especial en C que permite almacenar diferentes tipos de datos en la misma ubicación de memoria. Puedes definir una unión con muchos miembros, pero solo un miembro puede contener un valor en un momento dado. Las uniones proporcionan una forma eficiente de usar la misma ubicación para múltiples propósitos.

Definiendo una unión

Para definir una unión, usa la sentencia union igual que al definir una estructura. Define un nuevo tipo con más de un miembro. Formato:

union [etiqueta_unión] {
    definición_miembro;
    definición_miembro;
    ...
    definición_miembro;
} [una_o_más_variables_unión];

La etiqueta_unión es opcional y cada definición de miembro es normal (int i;, float f;, etc.). Al final, antes del punto y coma, puedes especificar variables de unión (opcional). Definición de unión Data con tres miembros i, f, str:

union Data {
    int i;
    float f;
    char str[20];
} data;

Una variable de tipo Data puede almacenar un entero, un flotante o una cadena. Una sola variable (misma ubicación) sirve para múltiples tipos. Puedes usar cualquier tipo integrado o definido por usuario dentro de una unión.

La memoria ocupada por una unión es lo suficientemente grande para el miembro más grande. En el ejemplo, Data ocupa 20 bytes (tamaño del array de caracteres). Ejemplo que muestra el tamaño:

Demo en vivo

#include <stdio.h>
#include <string.h>
union Data {
    int i;
    float f;
    char str[20];
};
int main() {
    union Data data;
    printf("Tamaño de memoria ocupado por data: %d\n", sizeof(data));
    return 0;
}

Resultado:

Tamaño de memoria ocupado por data: 20

Acceso a miembros de unión

Para acceder a cualquier miembro, usamos el operador de acceso a miembro (.): punto entre nombre de variable unión y miembro. Usa union para definir variables de tipo unión. Ejemplo de uso:

Demo en vivo

#include <stdio.h>
#include <string.h>
union Data {
    int i;
    float f;
    char str[20];
};
int main() {
    union Data data;
    data.i = 10;
    data.f = 220.5;
    strcpy(data.str, "Programación en C");
    printf("data.i: %d\n", data.i);
    printf("data.f: %f\n", data.f);
    printf("data.str: %s\n", data.str);
    return 0;
}

Resultado:

data.i: 1917853763
data.f: 4122360580327794860452759994368.000000
data.str: Programación en C

Aquí vemos que los valores de i y f se corrompieron porque el valor final asignado (str) ocupó la memoria; por eso str se imprime bien.

Ahora usemos un miembro a la vez, que es el propósito principal de las uniones:

Demo en vivo

#include <stdio.h>
#include <string.h>
union Data {
    int i;
    float f;
    char str[20];
};
int main() {
    union Data data;
    data.i = 10;
    printf("data.i: %d\n", data.i);
    data.f = 220.5;
    printf("data.f: %f\n", data.f);
    strcpy(data.str, "Programación en C");
    printf("data.str: %s\n", data.str);
    return 0;
}

Resultado:

data.i: 10
data.f: 220.500000
data.str: Programación en C

Ahora todos los miembros se imprimen correctamente porque se usa uno a la vez.