Miembros de array flexible en estructuras C para manejo dinámico de datos

¿Qué son los miembros de array flexible?

Los miembros de array flexible (Flexible Array Members, FAM) permiten incluir un array de tamaño variable al final de una estructura. Su tamaño se determina en tiempo de ejecución mediante asignación dinámica (malloc(), calloc(), realloc()). Se declaran con corchetes vacíos [] y deben ser el último miembro de la estructura, precedidos por al menos un miembro de tamaño fijo.

Sintaxis

struct NombreEstructura {
    tipo_dato miembro_fijo;
    tipo_dato array_flexible[]; // sin tamaño fijo
};

Asignación de memoria

El operador sizeof solo devuelve el tamaño de los miembros fijos. La memoria total requerida:

Total = sizeof(estructura) + (num_elementos * sizeof(tipo_elemento))

Ejemplo: estructura con int id (4 bytes) y array flexible de 5 int (20 bytes) → 24 bytes totales.

Ejemplo 1: Asignación y cálculo de memoria

#include <stdio.h>
#include <stdlib.h>
struct Ejemplo { int id; int arr[]; };
int main() {
    int n = 5;
    struct Ejemplo *e = malloc(sizeof(struct Ejemplo) + n * sizeof(int));
    if (e) {
        printf("Memoria total: %zu bytes\n", sizeof(struct Ejemplo) + n * sizeof(int));
        free(e);
    }
    return 0;
}

Salida: Memoria total: 24 bytes.

Ejemplo 2: Acceso a elementos del array flexible

struct Estudiante { int id; int notas[]; };
int main() {
    int materias = 3;
    struct Estudiante *s = malloc(sizeof(struct Estudiante) + materias * sizeof(int));
    if (s) {
        s->id = 102;
        s->notas[0] = 80; s->notas[1] = 75; s->notas[2] = 88;
        printf("ID: %d\nNotas: %d, %d, %d\n", s->id, s->notas[0], s->notas[1], s->notas[2]);
        free(s);
    }
    return 0;
}

Salida: ID: 102 / Notas: 80, 75, 88 / Memoria: 16 bytes (asumiendo int de 4 bytes y sin padding extra).

Redimensionamiento dinámico con realloc()

Para ampliar el array flexible, usar realloc() con el nuevo tamaño total. Siempre guardar el resultado en un puntero temporal para no perder la referencia original si falla.

struct Estudiante { int id; int cuenta; int notas[]; };
int main() {
    int inicial = 3;
    struct Estudiante *s = malloc(sizeof(struct Estudiante) + inicial * sizeof(int));
    s->id = 101; s->cuenta = inicial;
    // ... usar s->notas[0..2] ...
    int nuevo = 6;
    struct Estudiante *tmp = realloc(s, sizeof(struct Estudiante) + nuevo * sizeof(int));
    if (tmp) {
        s = tmp;
        s->cuenta = nuevo;
        // ahora s->notas[3..5] disponibles
    }
    free(s);
    return 0;
}

La estructura mantiene su tamaño fijo (8 bytes: id + cuenta), mientras el array crece de 12 a 24 bytes (total 20 → 32 bytes).

Conclusión

Los miembros de array flexible ahorran memoria, se adaptan a tamaños variables y simplifican la gestión de datos de longitud desconocida en tiempo de compilación. Son ideales para buffers, listas de longitud variable y estructuras de datos dinámicas.