Estructuras dentro de estructuras

Las estructuras en C nos permiten agrupar diferentes tipos de datos bajo un mismo nombre. Una característica muy útil es que podemos incluir una estructura dentro de otra, creando lo que llamamos estructuras anidadas. Esta técnica nos ayuda a organizar datos relacionados de forma jerárquica y lógica.

Imagina que estamos modelando información de una persona. Podríamos tener datos como nombre y edad, pero también necesitamos almacenar su dirección completa. En lugar de tener variables sueltas para calle, ciudad y código postal, podemos crear una estructura Direccion y luego incluirla dentro de una estructura Persona.

Definición de estructuras anidadas

Para crear estructuras anidadas, primero definimos las estructuras individuales y luego las combinamos:

// Primero definimos la estructura que estará anidada
struct Direccion {
    char calle[50];
    char ciudad[30];
    int codigo_postal;
};

// Luego definimos la estructura principal que contiene la otra
struct Persona {
    char nombre[50];
    int edad;
    struct Direccion domicilio;  // Estructura anidada
};

En este ejemplo, struct Persona contiene un campo llamado domicilio que es del tipo struct Direccion. Esto crea una relación jerárquica entre ambas estructuras.

Ventajas de las estructuras anidadas

Las estructuras anidadas ofrecen varias ventajas:

• Organización lógica: Agrupan datos relacionados de manera natural
• Modularidad: Facilitan la reutilización de estructuras en diferentes contextos
• Legibilidad: Hacen que el código sea más fácil de entender y mantener

Uso de estructuras anidadas

Veamos cómo declarar y utilizar variables con estructuras anidadas:

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

int main() {
    // Declaramos una variable de tipo Persona
    struct Persona empleado;
    
    // Asignamos valores a los campos simples
    strcpy(empleado.nombre, "Ana García");
    empleado.edad = 28;
    
    // Asignamos valores a los campos de la estructura anidada
    strcpy(empleado.domicilio.calle, "Calle Mayor 123");
    strcpy(empleado.domicilio.ciudad, "Madrid");
    empleado.domicilio.codigo_postal = 28001;
    
    return 0;
}

Estructuras anidadas en arreglos

También podemos crear arreglos de estructuras que contienen otras estructuras:

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

int main() {
    // Arreglo de 3 personas
    struct Persona empleados[3];
    
    // Asignamos datos al primer empleado
    strcpy(empleados[0].nombre, "Carlos López");
    empleados[0].edad = 35;
    strcpy(empleados[0].domicilio.calle, "Avenida Principal 45");
    strcpy(empleados[0].domicilio.ciudad, "Barcelona");
    empleados[0].domicilio.codigo_postal = 08001;
    
    // Podríamos seguir con los demás empleados...
    
    return 0;
}

Anidación múltiple

Podemos llevar la anidación a varios niveles, aunque es recomendable no excederse para mantener la claridad del código:

struct Contacto {
    char telefono[15];
    char email[50];
};

struct Direccion {
    char calle[50];
    char ciudad[30];
    int codigo_postal;
    struct Contacto info_contacto;  // Anidación de segundo nivel
};

struct Persona {
    char nombre[50];
    int edad;
    struct Direccion domicilio;  // Anidación de primer nivel
};

En este ejemplo, struct Persona contiene struct Direccion, que a su vez contiene struct Contacto, creando una jerarquía de tres niveles.

Ejemplo práctico: Sistema de gestión de estudiantes

Veamos un ejemplo más completo que muestra cómo las estructuras anidadas pueden ayudarnos a modelar situaciones del mundo real:

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

struct Fecha {
    int dia;
    int mes;
    int anio;
};

struct Asignatura {
    char nombre[50];
    float calificacion;
};

struct Estudiante {
    char nombre[50];
    int id;
    struct Fecha fecha_nacimiento;
    struct Asignatura materias[5];
};

int main() {
    struct Estudiante alumno;
    
    // Datos personales
    strcpy(alumno.nombre, "Laura Martínez");
    alumno.id = 12345;
    
    // Fecha de nacimiento
    alumno.fecha_nacimiento.dia = 15;
    alumno.fecha_nacimiento.mes = 7;
    alumno.fecha_nacimiento.anio = 2000;
    
    // Primera asignatura
    strcpy(alumno.materias[0].nombre, "Programación");
    alumno.materias[0].calificacion = 8.5;
    
    // Segunda asignatura
    strcpy(alumno.materias[1].nombre, "Matemáticas");
    alumno.materias[1].calificacion = 9.0;
    
    // Mostramos algunos datos
    printf("Estudiante: %s (ID: %d)\n", alumno.nombre, alumno.id);
    printf("Fecha de nacimiento: %d/%d/%d\n", 
           alumno.fecha_nacimiento.dia, 
           alumno.fecha_nacimiento.mes, 
           alumno.fecha_nacimiento.anio);
    printf("Calificación en %s: %.1f\n", 
           alumno.materias[0].nombre, 
           alumno.materias[0].calificacion);
    
    return 0;
}

Este programa muestra cómo podemos modelar un sistema de gestión de estudiantes utilizando estructuras anidadas para representar la fecha de nacimiento y las asignaturas cursadas.

Las estructuras anidadas son una herramienta fundamental en C para organizar datos complejos de manera lógica y estructurada. Permiten crear modelos de datos que reflejan relaciones jerárquicas del mundo real, facilitando el desarrollo de programas más organizados y mantenibles.

Acceso a campos anidados

Cuando trabajamos con estructuras anidadas en C, necesitamos una forma de acceder a los campos que se encuentran en diferentes niveles de anidación. El lenguaje C proporciona una sintaxis clara y directa para esto mediante el operador punto (.), que se utiliza de forma encadenada para navegar a través de los diferentes niveles de la estructura.

Para acceder a un campo dentro de una estructura anidada, simplemente encadenamos los nombres de los campos usando el operador punto, avanzando desde el nivel más externo hasta el más interno:

estructura_externa.estructura_interna.campo

Sintaxis básica de acceso

Tomando como referencia las estructuras que vimos anteriormente:

#include <stdio.h>

int main() {
    struct Direccion {
        char calle[50];
        char ciudad[30];
        int codigo_postal;
    };

    struct Persona {
        char nombre[50];
        int edad;
        struct Direccion domicilio;
    };
    
    struct Persona empleado;
    
    // Acceso a campos de primer nivel
    printf("Nombre: %s\n", empleado.nombre);
    printf("Edad: %d\n", empleado.edad);
    
    // Acceso a campos anidados
    printf("Calle: %s\n", empleado.domicilio.calle);
    printf("Ciudad: %s\n", empleado.domicilio.ciudad);
    printf("Código postal: %d\n", empleado.domicilio.codigo_postal);
    
    return 0;
}

En este ejemplo, empleado.domicilio.calle nos permite acceder al campo calle que está dentro de la estructura domicilio, que a su vez está dentro de la variable empleado.

Modificación de campos anidados

El acceso a campos anidados funciona tanto para lectura como para escritura. Podemos asignar valores directamente usando la misma notación:

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

int main() {
    struct Direccion {
        char calle[50];
        char ciudad[30];
        int codigo_postal;
    };

    struct Persona {
        char nombre[50];
        int edad;
        struct Direccion domicilio;
    };
    
    struct Persona empleado;
    
    // Modificación de campos de primer nivel
    strcpy(empleado.nombre, "Juan Pérez");
    empleado.edad = 30;
    
    // Modificación de campos anidados
    strcpy(empleado.domicilio.calle, "Gran Vía 42");
    strcpy(empleado.domicilio.ciudad, "Sevilla");
    empleado.domicilio.codigo_postal = 41001;
    
    // Verificamos los valores
    printf("Empleado: %s, %d años\n", empleado.nombre, empleado.edad);
    printf("Dirección: %s, %s, %d\n", 
           empleado.domicilio.calle, 
           empleado.domicilio.ciudad, 
           empleado.domicilio.codigo_postal);
    
    return 0;
}

Acceso a través de punteros

Cuando trabajamos con punteros a estructuras, la sintaxis cambia ligeramente. En lugar del operador punto (.), usamos el operador flecha (->) para acceder a los campos:

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

int main() {
    struct Direccion {
        char calle[50];
        char ciudad[30];
        int codigo_postal;
    };

    struct Persona {
        char nombre[50];
        int edad;
        struct Direccion domicilio;
    };
    
    // Creamos una persona usando memoria dinámica
    struct Persona *p_empleado = (struct Persona *)malloc(sizeof(struct Persona));
    
    // Acceso a campos a través de punteros
    strcpy(p_empleado->nombre, "María López");
    p_empleado->edad = 25;
    
    // Acceso a campos anidados a través de punteros
    strcpy(p_empleado->domicilio.calle, "Paseo de la Castellana 100");
    strcpy(p_empleado->domicilio.ciudad, "Madrid");
    p_empleado->domicilio.codigo_postal = 28046;
    
    // Mostramos la información
    printf("Empleado: %s, %d años\n", p_empleado->nombre, p_empleado->edad);
    printf("Dirección: %s, %s, %d\n", 
           p_empleado->domicilio.calle, 
           p_empleado->domicilio.ciudad, 
           p_empleado->domicilio.codigo_postal);
    
    // Liberamos la memoria
    free(p_empleado);
    
    return 0;
}

Observa que usamos p_empleado->domicilio.calle y no p_empleado->domicilio->calle. Esto es porque domicilio no es un puntero, sino un campo de estructura dentro de la estructura a la que apunta p_empleado.

Acceso a campos en arreglos de estructuras

Cuando tenemos un arreglo de estructuras que contienen estructuras anidadas, combinamos la notación de arreglos con el acceso a campos:

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

int main() {
    struct Direccion {
        char calle[50];
        char ciudad[30];
        int codigo_postal;
    };

    struct Persona {
        char nombre[50];
        int edad;
        struct Direccion domicilio;
    };
    
    // Arreglo de 3 personas
    struct Persona equipo[3];
    
    // Asignamos datos a la primera persona
    strcpy(equipo[0].nombre, "Roberto García");
    equipo[0].edad = 42;
    strcpy(equipo[0].domicilio.calle, "Calle Real 15");
    strcpy(equipo[0].domicilio.ciudad, "Valencia");
    equipo[0].domicilio.codigo_postal = 46001;
    
    // Asignamos datos a la segunda persona
    strcpy(equipo[1].nombre, "Laura Sánchez");
    equipo[1].edad = 29;
    strcpy(equipo[1].domicilio.calle, "Avenida Libertad 23");
    strcpy(equipo[1].domicilio.ciudad, "Barcelona");
    equipo[1].domicilio.codigo_postal = 08001;
    
    // Mostramos la información de las dos primeras personas
    for (int i = 0; i < 2; i++) {
        printf("Persona %d:\n", i+1);
        printf("  Nombre: %s\n", equipo[i].nombre);
        printf("  Edad: %d\n", equipo[i].edad);
        printf("  Dirección: %s, %s, %d\n", 
               equipo[i].domicilio.calle, 
               equipo[i].domicilio.ciudad, 
               equipo[i].domicilio.codigo_postal);
        printf("\n");
    }
    
    return 0;
}

Acceso a campos en estructuras con múltiples niveles

Cuando tenemos más de dos niveles de anidación, simplemente extendemos la cadena de operadores punto para acceder a los campos más profundos:

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

int main() {
    struct Contacto {
        char telefono[15];
        char email[50];
    };

    struct Direccion {
        char calle[50];
        char ciudad[30];
        int codigo_postal;
        struct Contacto info_contacto;
    };

    struct Persona {
        char nombre[50];
        int edad;
        struct Direccion domicilio;
    };
    
    struct Persona cliente;
    
    // Asignamos valores a todos los niveles
    strcpy(cliente.nombre, "Pedro Martínez");
    cliente.edad = 35;
    
    strcpy(cliente.domicilio.calle, "Plaza Mayor 3");
    strcpy(cliente.domicilio.ciudad, "Zaragoza");
    cliente.domicilio.codigo_postal = 50001;
    
    strcpy(cliente.domicilio.info_contacto.telefono, "666-123-456");
    strcpy(cliente.domicilio.info_contacto.email, "pedro@ejemplo.com");
    
    // Accedemos a los campos en todos los niveles
    printf("Cliente: %s\n", cliente.nombre);
    printf("Teléfono: %s\n", cliente.domicilio.info_contacto.telefono);
    printf("Email: %s\n", cliente.domicilio.info_contacto.email);
    
    return 0;
}

En este ejemplo, cliente.domicilio.info_contacto.email nos permite acceder al campo email que está en el tercer nivel de anidación.

Ejemplo práctico: Sistema de inventario

Veamos un ejemplo más completo que muestra cómo acceder a campos en un sistema de inventario:

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

int main() {
    struct Fecha {
        int dia;
        int mes;
        int anio;
    };
    
    struct Proveedor {
        char nombre[50];
        char telefono[15];
    };
    
    struct Producto {
        int id;
        char nombre[50];
        float precio;
        int cantidad;
        struct Fecha fecha_ingreso;
        struct Proveedor suministrador;
    };
    
    // Creamos un inventario de 2 productos
    struct Producto inventario[2];
    
    // Producto 1
    inventario[0].id = 1001;
    strcpy(inventario[0].nombre, "Teclado mecánico");
    inventario[0].precio = 89.99;
    inventario[0].cantidad = 15;
    
    inventario[0].fecha_ingreso.dia = 10;
    inventario[0].fecha_ingreso.mes = 5;
    inventario[0].fecha_ingreso.anio = 2023;
    
    strcpy(inventario[0].suministrador.nombre, "TecnoSupply");
    strcpy(inventario[0].suministrador.telefono, "911-222-333");
    
    // Producto 2
    inventario[1].id = 1002;
    strcpy(inventario[1].nombre, "Ratón inalámbrico");
    inventario[1].precio = 45.50;
    inventario[1].cantidad = 30;
    
    inventario[1].fecha_ingreso.dia = 15;
    inventario[1].fecha_ingreso.mes = 5;
    inventario[1].fecha_ingreso.anio = 2023;
    
    strcpy(inventario[1].suministrador.nombre, "TecnoSupply");
    strcpy(inventario[1].suministrador.telefono, "911-222-333");
    
    // Mostramos el inventario
    printf("=== INVENTARIO ===\n\n");
    
    for (int i = 0; i < 2; i++) {
        printf("Producto: %s (ID: %d)\n", inventario[i].nombre, inventario[i].id);
        printf("Precio: %.2f € | Cantidad: %d unidades\n", 
               inventario[i].precio, inventario[i].cantidad);
        printf("Fecha de ingreso: %d/%d/%d\n", 
               inventario[i].fecha_ingreso.dia,
               inventario[i].fecha_ingreso.mes,
               inventario[i].fecha_ingreso.anio);
        printf("Proveedor: %s | Tel: %s\n\n", 
               inventario[i].suministrador.nombre,
               inventario[i].suministrador.telefono);
    }
    
    return 0;
}

Este ejemplo muestra cómo acceder a diferentes niveles de campos anidados en un contexto práctico de gestión de inventario.

El acceso a campos anidados en C es una técnica fundamental para trabajar con estructuras complejas. Aunque la sintaxis puede parecer un poco verbosa cuando hay varios niveles de anidación, proporciona una forma clara y directa de acceder y manipular los datos organizados jerárquicamente.

Inicialización de estructuras anidadas

Cuando trabajamos con estructuras anidadas en C, es importante saber cómo inicializarlas correctamente. La inicialización nos permite asignar valores a todos los campos de una estructura en el momento de su creación, lo que hace nuestro código más limpio y eficiente.

En C, podemos inicializar estructuras anidadas de varias formas, cada una con sus propias ventajas según el contexto. Veamos las diferentes técnicas disponibles.

Inicialización mediante llaves anidadas

La forma más directa de inicializar estructuras anidadas es utilizando llaves anidadas que siguen la jerarquía de las estructuras:

#include <stdio.h>

int main() {
    struct Direccion {
        char calle[50];
        char ciudad[30];
        int codigo_postal;
    };

    struct Persona {
        char nombre[50];
        int edad;
        struct Direccion domicilio;
    };
    
    // Inicialización completa en la declaración
    struct Persona empleado = {
        "Ana García",           // nombre
        28,                     // edad
        {                       // domicilio (estructura anidada)
            "Calle Mayor 123",  // domicilio.calle
            "Madrid",           // domicilio.ciudad
            28001               // domicilio.codigo_postal
        }
    };
    
    // Mostramos los datos para verificar
    printf("Nombre: %s\n", empleado.nombre);
    printf("Edad: %d\n", empleado.edad);
    printf("Dirección: %s, %s, %d\n", 
           empleado.domicilio.calle,
           empleado.domicilio.ciudad,
           empleado.domicilio.codigo_postal);
    
    return 0;
}

En este ejemplo, las llaves interiores { "Calle Mayor 123", "Madrid", 28001 } inicializan la estructura anidada domicilio.

Inicialización con designadores (C99 y posteriores)

A partir del estándar C99, podemos usar designadores para hacer la inicialización más clara y explícita:

#include <stdio.h>

int main() {
    struct Direccion {
        char calle[50];
        char ciudad[30];
        int codigo_postal;
    };

    struct Persona {
        char nombre[50];
        int edad;
        struct Direccion domicilio;
    };
    
    // Inicialización con designadores
    struct Persona empleado = {
        .nombre = "Carlos López",
        .edad = 35,
        .domicilio = {
            .calle = "Avenida Principal 45",
            .ciudad = "Barcelona",
            .codigo_postal = 08001
        }
    };
    
    printf("Empleado: %s, %d años\n", empleado.nombre, empleado.edad);
    printf("Vive en: %s, %s (%d)\n", 
           empleado.domicilio.calle,
           empleado.domicilio.ciudad,
           empleado.domicilio.codigo_postal);
    
    return 0;
}

Esta sintaxis tiene varias ventajas:

• Es más legible porque cada campo está etiquetado
• Permite inicializar campos específicos sin necesidad de seguir un orden estricto
• Hace el código más mantenible ya que es menos propenso a errores cuando cambia la estructura

Inicialización parcial

No es necesario inicializar todos los campos de una estructura. Los campos no inicializados se establecen automáticamente a cero (o cadena vacía para arrays de caracteres):

#include <stdio.h>

int main() {
    struct Direccion {
        char calle[50];
        char ciudad[30];
        int codigo_postal;
    };

    struct Persona {
        char nombre[50];
        int edad;
        struct Direccion domicilio;
    };
    
    // Inicialización parcial
    struct Persona cliente = {
        "María Rodríguez",
        42,
        { "Plaza del Sol 7" }  // Solo inicializamos la calle
    };
    
    printf("Cliente: %s (%d años)\n", cliente.nombre, cliente.edad);
    printf("Calle: %s\n", cliente.domicilio.calle);
    printf("Ciudad: %s (longitud: %lu)\n", cliente.domicilio.ciudad, strlen(cliente.domicilio.ciudad));
    printf("Código postal: %d\n", cliente.domicilio.codigo_postal);
    
    return 0;
}

En este ejemplo, solo inicializamos domicilio.calle, mientras que domicilio.ciudad será una cadena vacía y domicilio.codigo_postal será 0.

Inicialización de arreglos de estructuras anidadas

Podemos inicializar arreglos de estructuras que contienen estructuras anidadas:

#include <stdio.h>

int main() {
    struct Direccion {
        char calle[50];
        char ciudad[30];
        int codigo_postal;
    };

    struct Persona {
        char nombre[50];
        int edad;
        struct Direccion domicilio;
    };
    
    // Inicialización de un arreglo de estructuras con estructuras anidadas
    struct Persona equipo[3] = {
        {
            "Roberto García", 
            42, 
            { "Calle Real 15", "Valencia", 46001 }
        },
        {
            "Laura Sánchez", 
            29, 
            { "Avenida Libertad 23", "Barcelona", 08001 }
        },
        {
            "Miguel Torres", 
            35, 
            { "Calle Alcalá 67", "Madrid", 28009 }
        }
    };
    
    // Mostramos la información del equipo
    for (int i = 0; i < 3; i++) {
        printf("Miembro %d:\n", i+1);
        printf("  Nombre: %s\n", equipo[i].nombre);
        printf("  Edad: %d\n", equipo[i].edad);
        printf("  Dirección: %s, %s, %d\n\n", 
               equipo[i].domicilio.calle, 
               equipo[i].domicilio.ciudad, 
               equipo[i].domicilio.codigo_postal);
    }
    
    return 0;
}

Inicialización con múltiples niveles de anidación

Para estructuras con varios niveles de anidación, simplemente extendemos el patrón de llaves anidadas:

#include <stdio.h>

int main() {
    struct Contacto {
        char telefono[15];
        char email[50];
    };

    struct Direccion {
        char calle[50];
        char ciudad[30];
        int codigo_postal;
        struct Contacto info_contacto;
    };

    struct Persona {
        char nombre[50];
        int edad;
        struct Direccion domicilio;
    };
    
    // Inicialización con múltiples niveles
    struct Persona cliente = {
        "Pedro Martínez",                // nombre
        35,                              // edad
        {                                // domicilio
            "Plaza Mayor 3",             // domicilio.calle
            "Zaragoza",                  // domicilio.ciudad
            50001,                       // domicilio.codigo_postal
            {                            // domicilio.info_contacto
                "666-123-456",           // domicilio.info_contacto.telefono
                "pedro@ejemplo.com"      // domicilio.info_contacto.email
            }
        }
    };
    
    // Con designadores sería así (más legible):
    struct Persona cliente2 = {
        .nombre = "Lucía Fernández",
        .edad = 29,
        .domicilio = {
            .calle = "Gran Vía 42",
            .ciudad = "Bilbao",
            .codigo_postal = 48001,
            .info_contacto = {
                .telefono = "777-987-654",
                .email = "lucia@ejemplo.com"
            }
        }
    };
    
    // Mostramos la información del primer cliente
    printf("Cliente: %s\n", cliente.nombre);
    printf("Edad: %d años\n", cliente.edad);
    printf("Dirección: %s, %s, %d\n", 
           cliente.domicilio.calle,
           cliente.domicilio.ciudad,
           cliente.domicilio.codigo_postal);
    printf("Teléfono: %s\n", cliente.domicilio.info_contacto.telefono);
    printf("Email: %s\n", cliente.domicilio.info_contacto.email);
    
    return 0;
}

Inicialización de estructuras anidadas con typedef

Cuando usamos typedef para crear alias de nuestras estructuras, la inicialización funciona exactamente igual:

#include <stdio.h>

typedef struct {
    char calle[50];
    char ciudad[30];
    int codigo_postal;
} Direccion;

typedef struct {
    char nombre[50];
    int edad;
    Direccion domicilio;  // Estructura anidada usando typedef
} Persona;

int main() {
    // La inicialización es idéntica
    Persona estudiante = {
        "Javier Gómez",
        19,
        { "Calle Universidad 10", "Salamanca", 37001 }
    };
    
    // Con designadores
    Persona profesor = {
        .nombre = "Elena Martín",
        .edad = 45,
        .domicilio = {
            .calle = "Avenida de la Ciencia 23",
            .ciudad = "Salamanca",
            .codigo_postal = 37007
        }
    };
    
    printf("Estudiante: %s\n", estudiante.nombre);
    printf("Dirección: %s, %s\n\n", 
           estudiante.domicilio.calle,
           estudiante.domicilio.ciudad);
           
    printf("Profesor: %s\n", profesor.nombre);
    printf("Dirección: %s, %s\n", 
           profesor.domicilio.calle,
           profesor.domicilio.ciudad);
    
    return 0;
}

Ejemplo práctico: Sistema de gestión de biblioteca

Veamos un ejemplo más completo que muestra la inicialización de estructuras anidadas en un contexto práctico:

#include <stdio.h>

int main() {
    struct Fecha {
        int dia;
        int mes;
        int anio;
    };
    
    struct Autor {
        char nombre[50];
        char nacionalidad[30];
    };
    
    struct Libro {
        char titulo[100];
        struct Autor autor;
        int paginas;
        struct Fecha publicacion;
        float precio;
    };
    
    // Inicializamos un catálogo de libros
    struct Libro biblioteca[3] = {
        {
            "Cien años de soledad",
            { "Gabriel García Márquez", "Colombiana" },
            471,
            { 5, 6, 1967 },
            19.95
        },
        {
            "El Quijote",
            { "Miguel de Cervantes", "Española" },
            863,
            { 16, 1, 1605 },
            24.50
        },
        {
            "1984",
            { "George Orwell", "Británica" },
            326,
            { 8, 6, 1949 },
            15.75
        }
    };
    
    // Mostramos el catálogo
    printf("=== CATÁLOGO DE BIBLIOTECA ===\n\n");
    
    for (int i = 0; i < 3; i++) {
        printf("Libro: %s\n", biblioteca[i].titulo);
        printf("Autor: %s (%s)\n", 
               biblioteca[i].autor.nombre,
               biblioteca[i].autor.nacionalidad);
        printf("Publicado: %d/%d/%d\n", 
               biblioteca[i].publicacion.dia,
               biblioteca[i].publicacion.mes,
               biblioteca[i].publicacion.anio);
        printf("Páginas: %d\n", biblioteca[i].paginas);
        printf("Precio: %.2f €\n\n", biblioteca[i].precio);
    }
    
    return 0;
}

Este ejemplo muestra cómo inicializar un arreglo de libros, donde cada libro contiene estructuras anidadas para el autor y la fecha de publicación.

Consejos prácticos para la inicialización

• Usa designadores cuando sea posible para mejorar la legibilidad
• Mantén la indentación adecuada para visualizar claramente la jerarquía
• Comenta los campos en inicializaciones complejas para facilitar el mantenimiento
• Evita anidaciones excesivas (más de 2-3 niveles) que dificulten la lectura
• Considera usar typedef para simplificar la declaración de estructuras complejas

La inicialización correcta de estructuras anidadas es una habilidad fundamental en C que te permitirá crear código más limpio, legible y menos propenso a errores. Dominar estas técnicas te ayudará a trabajar de manera más eficiente con estructuras de datos complejas.