Estructuras y uniones

El lenguaje C ofrece distintas maneras de agrupar y manejar la información para crear aplicaciones bien estructuradas. Entre los elementos más importantes destacan las estructuras, las uniones y los tipos definidos. Con estos recursos, es posible diseñar tipos de datos personalizados que representen entidades complejas, favoreciendo la legibilidad y la reutilización de código.

Estructuras en C

Una estructura permite combinar diferentes tipos de datos dentro de una misma entidad. Se define con la palabra reservada struct, seguida de los campos o miembros:

#include <stdio.h>

struct Persona {
    char nombre[50];
    int edad;
    float estatura;
};

int main() {
    struct Persona individuo;
    
    // Asignar valores
    individuo.edad = 30;
    individuo.estatura = 1.75;
    // Usar una función como scanf o strcpy para nombre
    
    printf("Edad: %d\n", individuo.edad);
    printf("Estatura: %.2f\n", individuo.estatura);
    return 0;
}

Las estructuras fomentan la organización de la información, ya que agrupan variables de distinta índole en un solo tipo. Para gestionar estas variables, se utiliza el operador . para acceder a los miembros.

Anidación de estructuras

Es posible incluir una estructura dentro de otra, lo cual potencia la creación de jerarquías de datos:

struct Direccion {
    char calle[100];
    int numero;
};

struct Persona {
    char nombre[50];
    struct Direccion domicilio;
    int edad;
};

Esta flexibilidad facilita la representación de entidades complejas en el lenguaje C.

Uniones en C

Las uniones se definen con la palabra reservada union y permiten almacenar diferentes tipos de datos en la misma ubicación de memoria. A diferencia de las estructuras, donde cada miembro ocupa su propio espacio, todas las variables de la unión comparten la misma región de memoria:

#include <stdio.h>

union Dato {
    int entero;
    float decimal;
};

int main() {
    union Dato valor;
    
    valor.entero = 10;
    printf("Entero: %d\n", valor.entero);
    
    valor.decimal = 3.14;
    printf("Decimal: %.2f\n", valor.decimal);
    
    // Al sobrescribir valor.decimal, se pierde el contenido de valor.entero
    return 0;
}

La unión permite optimizar el uso de la memoria cuando se sabe que solo se necesita un tipo de dato a la vez. Sin embargo, se debe tener cuidado, ya que modificar un campo implica sobrescribir los otros.

Tipos definidos con typedef

El typedef posibilita crear alias para simplificar la lectura y el mantenimiento de tipos complejos. Puede usarse con estructuras, uniones u otros tipos:

#include <stdio.h>

typedef struct {
    char nombre[50];
    int edad;
} Persona;

int main() {
    Persona p1;
    p1.edad = 25;
    // Asignar valor a p1.nombre
    
    printf("Edad: %d\n", p1.edad);
    return 0;
}

Al usar typedef, no es necesario escribir struct al crear variables. Esto hace más intuitivo el código y ayuda a entender mejor la naturaleza de cada dato.

Buenas prácticas

1. Usa nombres descriptivos para las estructuras y sus miembros, facilitando la comprensión de su propósito.
2. Evita abusar de las uniones si no es estrictamente necesario, pues pueden complicar la lógica de tu programa.
3. Combina el uso de typedef con estructuras y uniones para que la definición de datos sea más legible.
4. Verifica las copias y asignaciones de estructuras cuando contengan arrays o cadenas, asegurándote de manejar correctamente la memoria.

Ejemplo práctico

Un pequeño ejemplo que combine todo lo anterior para representar un archivo multimedia que pueda ser audio o vídeo, alternando la unión según el tipo:

#include <stdio.h>
#include <string.h>

typedef struct {
    int duracion;
    int bitrate;
} Audio;

typedef struct {
    float fps;
    int resolucionAncho;
    int resolucionAlto;
} Video;

typedef union {
    Audio audio;
    Video video;
} MediaUnion;

typedef struct {
    char tipo[10]; // "audio" o "video"
    char nombre[30];
    MediaUnion data;
} ArchivoMedia;

int main() {
    ArchivoMedia archivo;
    strcpy(archivo.tipo, "audio");
    strcpy(archivo.nombre, "MiCancion");

    // Asignar los datos de audio
    archivo.data.audio.duracion = 180;
    archivo.data.audio.bitrate = 320;

    // Mostrar información
    printf("Tipo: %s\n", archivo.tipo);
    printf("Nombre: %s\n", archivo.nombre);
    printf("Duración (segundos): %d\n", archivo.data.audio.duracion);
    printf("Bitrate (kbps): %d\n", archivo.data.audio.bitrate);

    return 0;
}

En este ejemplo, ArchivoMedia define un tipo que puede ser tanto de audio como de vídeo, representado por la unión MediaUnion. Se aprovecha también un typedef para simplificar la definición de cada componente.

Recomendaciones finales

• Analiza el uso apropiado de estructuras y uniones según las necesidades de memoria y la claridad requerida.
• Integra el typedef en tu código para reducir la complejidad en proyectos grandes.
• Realiza pruebas con ejemplos sencillos antes de aplicar estas técnicas a aplicaciones más complejas, garantizando un sólido entendimiento de los conceptos.