Diferencias entre union y struct

Las estructuras permiten agrupar varios campos de datos, reservando espacio independiente para cada uno y manteniéndolos accesibles de forma directa. Esto implica que una struct representa un bloque de memoria cuyo tamaño es la suma de los tamaños de todos sus miembros, lo cual facilita el tratamiento de datos que necesitan coexistir simultáneamente en el programa.

La unión (union), por el contrario, comparte la misma región de memoria entre todos sus miembros. Solo se reserva el espacio suficiente para el miembro de mayor tamaño, por lo que cuando se asigna un valor a un campo, se sobrescribe el contenido existente de la unión. Este esquema resulta útil cuando distintas variables nunca se usan al mismo tiempo y se busca optimizar el consumo de memoria.

Una diferencia notable radica en cómo se calculan las direcciones de cada miembro. En una struct, cada campo tiene su dirección única, mientras que en una union todos los miembros comparten el mismo inicio de dirección. Este detalle hace que, en la práctica, la lectura de un campo de la unión sea coherente solo si no se ha modificado previamente con otro miembro en uso.

En proyectos donde se requiere almacenar datos heterogéneos pero exclusivos entre sí, el empleo de una union puede resultar clave. Por ejemplo, si en cierto momento las variables necesarias son solo de tipo int o float, pero nunca se requiere que ambas existan simultáneamente, se puede ahorrar memoria mediante una unión:

union Dato {
    int entero;
    float decimal;
};

En cambio, cuando se necesita mantener todos los valores accesibles al mismo tiempo, se opta por estructuras. Un ejemplo es la siguiente struct, en la que cada campo debe estar disponible en cualquier momento:

struct Dato {
    int entero;
    float decimal;
};

En síntesis, struct proporciona almacenamiento individual para cada miembro, mientras que union comparte el mismo bloque de memoria, reflejando enfoques distintos para gestionar datos compuestos y permitiendo elegir la forma más adecuada según las necesidades de cada caso.

Declaración, acceso y uso de uniones

La declaración de una unión en C se realiza mediante la palabra clave union, seguida del nombre asignado y una lista de miembros encerrados entre llaves. Cada miembro se define del mismo modo que en una estructura, pero todos comparten la misma región de memoria. Tras la declaración, puede crearse una variable de ese tipo para su posterior uso en el programa.

Al instanciar una unión, se pueden asignar valores iniciales a uno de sus miembros utilizando asignación tradicional o inicializadores con punto (designated initializers). Por ejemplo:

#include <stdio.h>

union MiUnion
{
    char caracter;
    double numero;
};

int main(void)
{
    union MiUnion ejemplo = {.numero = 3.14};
    ejemplo.caracter = 'A';
    printf("Caracter: %c Numero: %f\n", ejemplo.caracter, ejemplo.numero);
    return 0;
}

Para acceder a los miembros, se emplea el operador punto (.) si se maneja la unión directamente, o el operador flecha (->) si se trata de un puntero. Es fundamental recordar que la modificación de un miembro afecta la memoria que utilizan los demás, por lo que la lectura de un campo diferente al último actualizado no reflejará valores anteriores.

En casos donde se necesite referenciar la unión a través de un puntero, se declara la variable puntero y se reserva espacio para la unión, ya sea de manera automática o dinámica. Una aproximación sencilla es:

union MiUnion dato;
union MiUnion *ptr = &dato;

ptr->numero = 45.0; 

Para evitar comportamientos imprevistos, se recomienda asignar y leer siempre del mismo miembro, a menos que exista un propósito claro de reinterpretar el contenido de la unión. Esta precaución resulta especialmente relevante en contextos de compatibilidad binaria o procesamiento de flujos de datos donde se reempaquetan tipos.

Enumeraciones (enum) para valores constantes y legibilidad

Una enumeración se declara en C empleando la palabra clave enum, seguida de un identificador y una lista de nombres simbólicos separados por comas. Cada elemento recibe un valor entero subyacente que se asigna secuencialmente a partir de 0, a menos que se especifique un valor concreto:

enum Estado {
    INACTIVO,  /* valor 0 */
    ACTIVO,    /* valor 1 */
    PAUSADO    /* valor 2 */
};

enum Estado estadoActual = ACTIVO;

Los valores nombrados en una enumeración agilizan la lectura de condicionales y facilitan la detección de errores lógicos, dado que reemplazan literales numéricos por identificadores más descriptivos. Conviene mantener la enumeración en un ámbito accesible cuando varios módulos del proyecto comparten estos valores.

El compilador asocia un tipo entero a cada enumeración, por lo que las operaciones con valores enum se realizan como si fueran enteros, permitiendo comparaciones y asignaciones de forma directa. Sin embargo, es habitual usar switch-case o estructuras de control similares para gestionar la legibilidad del código:

switch (estadoActual) {
    case INACTIVO:
        /* Lógica para estado inactivo */
        break;
    case ACTIVO:
        /* Código relevante cuando está activo */
        break;
    case PAUSADO:
        /* Tratamiento del estado pausado */
        break;
    default:
        /* Manejo de casos inesperados */
        break;
}

La asignación de valores iniciales puede ayudar a vincular la enumeración con códigos externos. Por ejemplo, si existe un protocolo o diccionario de claves, se pueden definir valores fijos para cada elemento, expresados con claridad:

enum CodigoError {
    EXITO = 0,
    ERROR_FICHERO = 100,
    ERROR_SOCKET = 200
};

Situar la declaración enum en un archivo de cabecera comparte de forma eficiente las constantes con distintos ficheros de implementación. Además, hacer un uso cuidadoso de estos nombres contribuye a mejorar la mantenibilidad y la coherencia de grandes sistemas.