malloc, calloc, realloc y free

1. Para qué sirve la memoria dinámica

Hasta aquí vimos tres duraciones para los datos, en el tema 6: la automática, de las variables locales, que vive lo que dura la llamada; la estática, de las globales, que vive todo el programa; y una tercera que quedó anunciada, la dinámica, que vive desde que el programa la pide hasta que la devuelve. Se necesita en tres situaciones:

• El tamaño se conoce en tiempo de ejecución. Un programa que lee un archivo no sabe cuántas líneas tiene hasta leerlo. Un arreglo local de tamaño fijo se queda corto o desperdicia espacio, y los arreglos de longitud variable del tema 17 viven en la pila, que tiene 8 MiB, como vimos en el tema 27.
• El dato debe sobrevivir a la función que lo crea. El tema 12 estableció que no se devuelve la dirección de una variable local. La alternativa que quedó pendiente es devolver la dirección de un bloque de memoria dinámica, que no desaparece al volver.
• El dato es grande o su cantidad crece. Una lista, un árbol o una tabla que se va llenando no caben en una cantidad fija de variables.

La memoria dinámica sale del montículo, la región [heap] y las regiones de mmap que vimos en el tema 27. Las funciones de este tema, declaradas en stdlib.h, son la interfaz con el administrador de memoria de la biblioteca de C, que a su vez pide más al núcleo con brk y mmap cuando lo necesita. El ciclo siempre tiene tres pasos: pedir un bloque, usarlo con la dirección que se recibe, y devolverlo. A diferencia de las variables locales, nadie hace los dos últimos pasos por el programador. Olvidar devolver un bloque es una fuga; devolverlo dos veces o usarlo después de devolverlo es un error grave; y ninguna de las dos cosas la detecta el compilador.

2. malloc y free

void *malloc(size_t n) reserva un bloque de n bytes y devuelve su dirección, o NULL si no pudo. void free(void *p) lo devuelve. El bloque tiene el contenido que haya tenido la memoria antes: malloc no lo inicializa. Este programa reserva un arreglo de enteros del tamaño que se le indique:

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

int main(int argc, char *argv[])
{
    if (argc != 2) {
        fprintf(stderr, "uso: %s cantidad\n", argv[0]);
        return 2;
    }
    size_t n = strtoul(argv[1], NULL, 10);
    int *v = malloc(n * sizeof *v);       /* n enteros: sizeof *v sigue al tipo de v */

    if (v == NULL) {
        fprintf(stderr, "%s: sin memoria para %zu enteros\n", argv[0], n);
        return 1;
    }
    long suma = 0;
    for (size_t i = 0; i < n; i++) {
        v[i] = (int) (i * i);
        suma += v[i];
    }
    printf("%zu enteros en %p, suma = %ld\n", n, (void *) v, suma);
    free(v);
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -g -o basico basico.c
$ ./basico 10
10 enteros en 0x56e42a8fe010, suma = 285
$ ./basico 1000000
1000000 enteros en 0x76a326c2f010, suma = 16866920716384
$ ./basico 99999999999999; echo $?
./basico: sin memoria para 99999999999999 enteros
1

Varios detalles de las pocas líneas que importan:

• No hace falta convertir el resultado. malloc devuelve un void *, que en C se convierte solo a cualquier tipo de puntero, como vimos con memcpy en el tema 15. Escribir (int *) malloc(…) es innecesario, y puede ocultar un error grave: si falta el #include <stdlib.h>, el compilador supone que malloc devuelve int, y el cast hace callar la queja sobre la conversión. En C++ el cast sí es obligatorio, pero este es un curso de C.
• n * sizeof *v en vez de n * sizeof(int). El tamaño se calcula a partir de la variable que recibirá el bloque. Si algún día v pasa a ser long *, el pedido se corrige solo; con sizeof(int) habría que acordarse de cambiarlo, y el error saldría como un desbordamiento. Como sizeof no evalúa su operando, *v es válido aunque v todavía no apunte a nada.
• El bloque se usa como cualquier arreglo: v[i] es *(v + i), la aritmética del tema 18. Pero sizeof v vale 8, el tamaño de un puntero: el tamaño del bloque no está en ningún lado que el programa pueda consultar, y hay que guardarlo en una variable aparte, como n.
• El contenido inicial es indeterminado. Leer un elemento antes de escribirlo es comportamiento indefinido, como con una variable local sin inicializar. A veces el bloque llega en cero, porque la memoria es nueva y el núcleo la entrega en cero (sección 4), y a veces con restos de un uso anterior; programa que funciona «porque da cero» es un error latente.
• Cada malloc exitoso tiene que tener su free. Cuando el programa termina, el sistema recupera toda su memoria, así que olvidar el free final de un programa de vida corta no deja secuelas; pero un programa que corre mucho tiempo, o que repite el pedido en un bucle, pierde memoria sin límite (fugas, tema 29).

3. Comprobar cada pedido

Un pedido puede fallar, y entonces malloc devuelve NULL y deja errno en ENOMEM. Desreferenciar ese NULL termina el programa con Segmentation fault, como vimos en el tema 27. Por eso todo pedido se comprueba, siempre, aunque «nunca falle». Este programa intenta siete tamaños, desde 1 MiB hasta el máximo posible:

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

static void probar(const char *que, size_t n)
{
    errno = 0;
    void *p = malloc(n);

    if (p != NULL)
        printf("%-22s -> %p\n", que, p);
    else
        printf("%-22s -> NULL (errno = %d: %s)\n", que, errno, strerror(errno));
    free(p);
}

int main(void)
{
    probar("malloc(1 MiB)", (size_t) 1 << 20);
    probar("malloc(1 GiB)", (size_t) 1 << 30);
    probar("malloc(64 GiB)", (size_t) 64 << 30);
    probar("malloc(1 TiB)", (size_t) 1 << 40);
    probar("malloc(1 << 62)", (size_t) 1 << 62);
    probar("malloc(SIZE_MAX)", SIZE_MAX);
    probar("malloc(0)", 0);
    return 0;
}

$ ./pedidos
malloc(1 MiB)          -> 0x7032550ff010
malloc(1 GiB)          -> 0x7032151ff010
malloc(64 GiB)         -> NULL (errno = 12: Cannot allocate memory)
malloc(1 TiB)          -> NULL (errno = 12: Cannot allocate memory)
malloc(1 << 62)        -> NULL (errno = 12: Cannot allocate memory)
malloc(SIZE_MAX)       -> NULL (errno = 12: Cannot allocate memory)
malloc(0)              -> 0x5eb7449b2020
$ (ulimit -v 200000; ./pedidos)
malloc(1 MiB)          -> 0x7b38b6e66010
malloc(1 GiB)          -> NULL (errno = 12: Cannot allocate memory)
malloc(64 GiB)         -> NULL (errno = 12: Cannot allocate memory)
malloc(1 TiB)          -> NULL (errno = 12: Cannot allocate memory)
malloc(1 << 62)        -> NULL (errno = 12: Cannot allocate memory)
malloc(SIZE_MAX)       -> NULL (errno = 12: Cannot allocate memory)
malloc(0)              -> 0x5bfc5f429040

El resultado enseña cómo falla de verdad la memoria en Linux:

• Un pedido de 1 GiB tuvo éxito y uno de 64 GiB, no, en una máquina de 16 GB de memoria y 4 GB de intercambio. Linux, por omisión (/proc/sys/vm/overcommit_memory vale 0), no reserva memoria física al hacer malloc, solo espacio de direcciones; la memoria real se entrega al tocar las páginas, como vimos en el tema 27. Por eso acepta pedidos grandes, mientras no sean absurdos: rechaza solo los que superan por mucho lo que el sistema podría dar.
• Que un pedido tenga éxito no garantiza que la memoria exista. Si el programa toca más memoria de la que el sistema puede dar, el fallo no ocurre en malloc sino después, en cualquier escritura, y el núcleo no devuelve un error: el OOM killer elige un proceso y lo mata con SIGKILL, y el shell informa Killed. Ningún if puede evitarlo.
• Con un límite explícito, el fallo es limpio. ulimit -v 200000 restringe el espacio de direcciones del proceso a unos 195 MiB, y entonces malloc(1 GiB) devuelve NULL. Es la forma de probar los caminos de error de un programa: sin un límite, casi nunca se ejecutan.
• Los pedidos imposibles también fallan con ENOMEM, hasta SIZE_MAX, sin ningún comportamiento especial.
• malloc(0) es válido. El estándar permite devolver NULL o un puntero único que no se debe desreferenciar pero sí liberar; glibc elige lo segundo. Por eso un resultado NULL no siempre es un error cuando el tamaño pedido puede ser cero: hay que comprobar el tamaño primero.

¿Qué se hace cuando el pedido falla? Depende del programa. Una biblioteca no decide por quien la usa: libera lo que haya reservado hasta ese punto y devuelve un error (un código o un puntero nulo), como hace contador_crear en la sección 9. Una herramienta de línea de órdenes chica, en cambio, no tiene cómo continuar sin memoria, y es habitual centralizar la decisión en una función propia que avisa y termina:

static void *reservar(size_t n)
{
    void *p = malloc(n);

    if (p == NULL && n != 0) {
        fprintf(stderr, "sin memoria al pedir %zu bytes\n", n);
        exit(EXIT_FAILURE);
    }
    return p;
}

El programa pierde la oportunidad de limpiar, pero cada llamada queda sin comprobación propia, y el mensaje sale siempre. Lo que no se admite es la tercera opción, ignorar el resultado: además de terminar el programa, desreferenciar un puntero nulo con un desplazamiento grande, como en p[1000000], puede alcanzar memoria que sí está mapeada y escribir donde no debe.

4. calloc y la multiplicación peligrosa

void *calloc(size_t n, size_t tam) reserva espacio para n elementos de tam bytes cada uno, y lo pone todo en cero. Se diferencia de malloc(n * tam) en dos cosas. La primera es evidente: el contenido inicial es conocido. La segunda no lo parece, y es la razón principal para preferirla cuando n o tam vienen de afuera: calloc comprueba que la multiplicación no se desborde.

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

struct registro {
    long a, b;                            /* 16 bytes */
};

int main(int argc, char *argv[])
{
    if (argc != 2) {
        fprintf(stderr, "uso: %s cantidad\n", argv[0]);
        return 2;
    }
    size_t n = strtoull(argv[1], NULL, 10);   /* una cantidad que llega de afuera */

    printf("n = %zu registros de %zu bytes\n", n, sizeof(struct registro));
    printf("n * sizeof(struct registro) = %zu\n", n * sizeof(struct registro));

    void *a = malloc(n * sizeof(struct registro));
    printf("malloc(n * tamaño) -> %s\n", a != NULL ? "un bloque" : "NULL");

    errno = 0;
    void *b = calloc(n, sizeof(struct registro));
    printf("calloc(n, tamaño)  -> %s (errno = %d: %s)\n",
           b != NULL ? "un bloque" : "NULL", errno, strerror(errno));
    free(a);
    free(b);
    return 0;
}

$ ./mult 1000
n = 1000 registros de 16 bytes
n * sizeof(struct registro) = 16000
malloc(n * tamaño) -> un bloque
calloc(n, tamaño)  -> un bloque (errno = 0: Success)
$ ./mult 1152921504606846977
n = 1152921504606846977 registros de 16 bytes
n * sizeof(struct registro) = 16
malloc(n * tamaño) -> un bloque
calloc(n, tamaño)  -> NULL (errno = 12: Cannot allocate memory)

Con una cantidad razonable los dos pedidos tienen éxito. Con n = 2⁶⁰ + 1, el producto con 16 se da la vuelta en la aritmética sin signo del tema 7 y vale 16: malloc recibe un pedido de 16 bytes, lo cumple sin quejarse, y devuelve un bloque con lugar para un registro, mientras el programa cree que tiene más de mil billones. Un programa que luego escriba n registros, o los primeros millones, escribe fuera del bloque. Este es un desbordamiento de entero que termina en un desbordamiento de memoria, un error clásico de seguridad: la cantidad de elementos llega de un archivo o de la red, y quien la envía elige un valor que haga dar la vuelta a la cuenta. calloc hace la multiplicación con comprobación, y ante el desbordamiento devuelve NULL con ENOMEM. Cuando los valores son constantes, gcc avisa del problema al compilar: product ‘1152921504606846977 * 16’ of arguments 1 and 2 exceeds ‘SIZE_MAX’ [-Walloc-size-larger-than=].

Hay una función para el caso en que no se quiere el relleno con ceros, reallocarray (de stdlib.h en glibc, con _DEFAULT_SOURCE): hace realloc con la misma comprobación. reallocarray(NULL, 10, sizeof *v) equivale a malloc de 10 elementos sin riesgo de desborde, y con una cantidad absurda devuelve NULL con ENOMEM y deja intacto el bloque original, lo que verificamos en una prueba con SIZE_MAX / 2 elementos de 4 bytes.

Queda el costo del relleno. Poner en cero 64 MiB parece caro, pero calloc es más inteligente que malloc más memset:

/* campo() e informe() son los de bss.c del tema 27 */
int main(void)
{
    informe("al empezar");

    char *a = calloc(1, TAM);
    informe("calloc(1, 64 MiB)");
    printf("  a[0] = %d, a[TAM - 1] = %d  (ceros, y casi sin gastar memoria)\n", a[0], a[TAM - 1]);

    char *b = malloc(TAM);
    informe("malloc(64 MiB)");
    memset(b, 0, TAM);
    informe("... y memset(b, 0, 64 MiB)");

    free(a);
    free(b);
    informe("después de los free");
    return 0;
}

$ ./perezoso
al empezar                         VmSize    2764 KiB  VmRSS    1408 KiB  fallos     82
calloc(1, 64 MiB)                  VmSize   68304 KiB  VmRSS    1664 KiB  fallos     94
  a[0] = 0, a[TAM - 1] = 0  (ceros, y casi sin gastar memoria)
malloc(64 MiB)                     VmSize  133844 KiB  VmRSS    1664 KiB  fallos     96
... y memset(b, 0, 64 MiB)         VmSize  133844 KiB  VmRSS   67200 KiB  fallos  16480
después de los free                VmSize    2764 KiB  VmRSS    1764 KiB  fallos  16480

El calloc de 64 MiB aumentó VmSize en 64 MiB y VmRSS en 256 KiB: casi nada. Para un bloque tan grande, malloc usa mmap, y la memoria que entrega el núcleo ya viene en cero, así que calloc sabe que no necesita escribir nada, y las páginas se asignan recién al tocarlas. En cambio el memset escribe en las 16 384 páginas y las vuelve todas reales: 16 384 fallos de página y 64 MiB más de VmRSS. Es la respuesta a la práctica 3 del tema 27. Y la última línea muestra que al hacer free de los bloques grandes el espacio de direcciones vuelve al tamaño del principio, porque malloc los devuelve al núcleo con munmap.

5. realloc: crecer sin perder lo que había

void *realloc(void *p, size_t n) cambia el tamaño de un bloque que se reservó antes: devuelve un bloque de n bytes con el mismo contenido que p, hasta el menor de los dos tamaños. Puede hacerlo de dos maneras: extender el bloque donde está, si hay lugar a continuación, o reservar otro bloque, copiar y liberar el viejo. El programa no sabe cuál ocurrió, así que debe usar siempre el puntero que devuelve, y nunca el anterior. Las reglas son cuatro:

• Si tiene éxito, el puntero viejo deja de ser válido, aunque coincida con el nuevo. Cualquier otra copia de la dirección, incluidos los punteros que apunten adentro del bloque, como &v[3], quedan colgantes cuando el bloque se mueve.
• Si falla, devuelve NULL y el bloque original queda intacto. Es la regla que causa el error más frecuente con realloc.
• realloc(NULL, n) equivale a malloc(n), lo que permite empezar un arreglo vacío con un puntero nulo.
• realloc(p, 0) hace algo distinto según la implementación (glibc libera el bloque y devuelve NULL); C17 lo deja a criterio de cada una y C23 lo declara comportamiento indefinido. Para liberar se usa free.

La segunda regla tiene una consecuencia para la forma de escribir la llamada. Este programa agranda un bloque hasta que realloc falla, con el espacio de direcciones limitado a unos 585 MiB para forzarlo, y lo hace de dos maneras:

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

int main(int argc, char *argv[])
{
    if (argc != 2) {
        fprintf(stderr, "uso: %s mal|bien\n", argv[0]);
        return 2;
    }
    int bien = strcmp(argv[1], "bien") == 0;
    size_t tam = 1 << 20;
    char *p = malloc(tam);

    if (p == NULL)
        return 1;
    strcpy(p, "datos importantes");

    for (;;) {
        size_t nuevo = tam * 2;

        if (bien) {
            char *tmp = realloc(p, nuevo);        /* el puntero viejo sigue en p */
            if (tmp == NULL)
                break;
            p = tmp;
        } else {
            p = realloc(p, nuevo);                /* si falla, p vale NULL */
            if (p == NULL)
                break;
        }
        tam = nuevo;
    }
    printf("realloc falló al pasar de %zu MiB a %zu MiB\n", tam >> 20, (tam * 2) >> 20);
    if (p != NULL)
        printf("p sigue siendo válido: \"%s\"\n", p);
    else
        printf("p vale NULL: se perdió el bloque de %zu MiB, que nadie puede liberar\n", tam >> 20);
    free(p);
    return 0;
}

$ (ulimit -v 600000; ./fallo_realloc mal)
realloc falló al pasar de 512 MiB a 1024 MiB
p vale NULL: se perdió el bloque de 512 MiB, que nadie puede liberar
$ (ulimit -v 600000; ./fallo_realloc bien)
realloc falló al pasar de 512 MiB a 1024 MiB
p sigue siendo válido: "datos importantes"

La forma p = realloc(p, nuevo) es la más escrita y la más peligrosa. Cuando falla, asigna NULL a p y destruye la única copia de la dirección del bloque viejo, que sigue reservado y que nadie puede ya usar ni liberar: es una fuga de 512 MiB, y además se pierde el contenido, los «datos importantes». La forma segura usa un puntero temporal: tmp = realloc(p, nuevo);, se comprueba, y solo si salió bien se hace p = tmp;. Si falla, p conserva el bloque y el programa puede guardar sus datos, liberar o seguir con lo que tiene. Es una de las reglas que se aprenden una vez y se aplican siempre.

La segunda cuestión es cuánto crecer. Este programa agrega 200 000 enteros de a uno a un arreglo, y compara cuatro estrategias, con y sin otros pedidos de memoria intercalados que impidan extender el bloque en el lugar:

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

enum { N = 200000 };

static void *vecinos[N];                  /* bloques que otros pedirían en el medio */

static double segundos(void)
{
    struct timespec t;

    clock_gettime(CLOCK_MONOTONIC, &t);
    return (double) t.tv_sec + (double) t.tv_nsec / 1e9;
}

/* agregar N enteros de a uno; ¿cuánto crece el arreglo en cada ampliación? */
static void probar(const char *estrategia, int duplicar, int con_vecinos)
{
    int *v = NULL;
    size_t cantidad = 0, capacidad = 0, nv = 0;
    long llamadas = 0, movidas = 0;
    double t0 = segundos();

    for (size_t i = 0; i < N; i++) {
        if (cantidad == capacidad) {
            size_t nueva = duplicar ? (capacidad == 0 ? 8 : capacidad * 2) : capacidad + 1;
            int *tmp = realloc(v, nueva * sizeof *v);

            if (tmp == NULL) {
                free(v);
                fprintf(stderr, "sin memoria\n");
                exit(1);
            }
            llamadas++;
            if (tmp != v && v != NULL)
                movidas++;
            v = tmp;
            capacidad = nueva;
            if (con_vecinos)
                vecinos[nv++] = malloc(16);       /* alguien más pide memoria */
        }
        v[cantidad++] = (int) i;
    }
    double t = segundos() - t0;

    printf("%-34s %7ld llamadas, %6ld movieron el bloque, %.4f s\n",
           estrategia, llamadas, movidas, t);
    free(v);
    for (size_t k = 0; k < nv; k++)
        free(vecinos[k]);
}

int main(void)
{
    probar("de a 1", 0, 0);
    probar("de a 1, con otros pedidos", 0, 1);
    probar("duplicando", 1, 0);
    probar("duplicando, con otros pedidos", 1, 1);
    return 0;
}

$ ./crecer
de a 1                              200000 llamadas,     27 movieron el bloque, 0.0020 s
de a 1, con otros pedidos           200000 llamadas,     76 movieron el bloque, 0.0064 s
duplicando                              16 llamadas,      1 movieron el bloque, 0.0007 s
duplicando, con otros pedidos           16 llamadas,      0 movieron el bloque, 0.0004 s

El resultado es menos dramático de lo que la teoría anuncia, y vale la pena entender por qué. Crecer de a uno obliga a copiar todo el contenido cada vez que el bloque se mueve, un trabajo proporcional al cuadrado de la cantidad de elementos; pero aquí el bloque casi nunca se movió, porque glibc lo extiende en el lugar cuando está al final del montículo, y para los bloques grandes usa mremap, que reubica páginas sin copiar sus datos (con strace se cuentan unas 160 llamadas a mremap). Aun así, la cuenta es clara: 200 000 llamadas contra 16, tiempo entre 3 y 10 veces mayor, y 76 movimientos cuando alguien más pide memoria en el medio. Y lo más importante, el resultado de la estrategia ingenua depende de la suerte del asignador: en otro sistema, o con bloques chicos, cada llamada puede copiar todo.

La estrategia que funciona siempre es el crecimiento geométrico: cuando el arreglo se llena, se pide el doble. Cada elemento se copia, en promedio, una o dos veces en toda la vida del arreglo, y el costo por elemento agregado es constante. Para eso hay que llevar dos números, que no son lo mismo: la cantidad de elementos que el arreglo tiene, y su capacidad, los que caben sin pedir más. El tema 30 construye un arreglo dinámico completo con esta técnica.

6. Las reglas de free

free(p) devuelve el bloque al administrador, que lo ofrecerá a un próximo pedido. Las reglas, todas sobre el puntero que se le pasa:

Todos los casos «indefinidos» son errores graves, y glibc detecta algunos de ellos y aborta el programa. Este programa los provoca, uno por cada argumento:

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

int main(int argc, char *argv[])
{
    char local[16] = "en la pila";
    char *p = malloc(32);

    if (argc != 2 || p == NULL)
        return 2;
    if (strcmp(argv[1], "nulo") == 0) {
        free(NULL);                       /* permitido: no hace nada */
        printf("free(NULL) no hizo nada\n");
    } else if (strcmp(argv[1], "pila") == 0) {
        free(local);
    } else if (strcmp(argv[1], "literal") == 0) {
        free((void *) "literal");
    } else if (strcmp(argv[1], "doble") == 0) {
        free(p);
        free(p);
    } else if (strcmp(argv[1], "medio") == 0) {
        free(p + 1);
    }
    printf("seguimos\n");
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -g -o mal_free mal_free.c
mal_free.c: In function ‘main’:
mal_free.c:21:9: warning: pointer ‘p’ used after ‘free’ [-Wuse-after-free]
mal_free.c:16:9: warning: ‘free’ called on unallocated object ‘local’ [-Wfree-nonheap-object]
mal_free.c:18:9: warning: ‘free’ called on a pointer to an unallocated object ‘"literal"’ [-Wfree-nonheap-object]
mal_free.c:23:9: warning: ‘free’ called on pointer ‘p’ with nonzero offset 1 [-Wfree-nonheap-object]
$ ./mal_free nulo
free(NULL) no hizo nada
seguimos
$ ./mal_free pila
double free or corruption (out)
Aborted
$ ./mal_free literal
free(): invalid pointer
Aborted
$ ./mal_free doble
free(): double free detected in tcache 2
Aborted
$ ./mal_free medio
free(): invalid pointer
Aborted

Las cuatro formas incorrectas se detectan, y por dos caminos. gcc las ve al compilar cuando las ve a la vista, con -Wuse-after-free y -Wfree-nonheap-object, ambos en -Wall: son los avisos que más vale no ignorar. Y glibc las ve al ejecutar, con comprobaciones internas que terminan el programa con SIGABRT y un mensaje. Pero hay que leer esos mensajes con cuidado: liberar una variable de la pila produce double free or corruption (out), que no menciona la pila, y free(): invalid pointer sirve igual para una cadena literal que para un puntero al medio de un bloque. Y lo que la biblioteca detecta es una fracción de lo que puede fallar: la mayoría de los errores con la memoria, como usar un bloque después de liberarlo, no producen ningún mensaje. De eso trata el tema 29.

Una costumbre defensiva es asignar NULL al puntero justo después de liberarlo, free(p); p = NULL;. Convierte la doble liberación en una llamada inocua, porque free(NULL) no hace nada, y hace que un uso posterior termine en Segmentation fault inmediato en lugar de leer memoria ajena. No es una solución, porque solo anula esa copia del puntero: si la dirección se guardó en otro lugar, esa otra copia sigue colgante.

7. Cadenas en memoria dinámica

Hasta ahora, las funciones que arman cadenas, como snprintf, necesitaban que quien llamaba aportara el buffer, con su tamaño. Con memoria dinámica, la función puede reservar el lugar justo y entregarlo, y el problema del tamaño desaparece. Quedaban dos promesas pendientes: strdup, anunciada en el tema 21, y la medición con snprintf(NULL, 0, …), del tema 22. Este programa tiene las dos, más una tercera opción:

#define _GNU_SOURCE                       /* asprintf */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>

/* como sprintf, pero reserva el lugar justo; quien llama debe hacer free */
static char *formato(const char *fmt, ...)
{
    va_list ap, copia;

    va_start(ap, fmt);
    va_copy(copia, ap);
    int n = vsnprintf(NULL, 0, fmt, ap);          /* primera pasada: medir */
    va_end(ap);
    if (n < 0) {
        va_end(copia);
        return NULL;
    }
    char *s = malloc((size_t) n + 1);
    if (s != NULL)
        vsnprintf(s, (size_t) n + 1, fmt, copia); /* segunda pasada: escribir */
    va_end(copia);
    return s;
}

/* strdup hecha a mano */
static char *copiar(const char *origen)
{
    size_t n = strlen(origen) + 1;                /* con el '\0' */
    char *copia = malloc(n);

    if (copia != NULL)
        memcpy(copia, origen, n);
    return copia;
}

int main(void)
{
    char original[] = "/proc/self/maps";
    char *a = copiar(original);
    char *b = strdup(original);
    char *c = formato("%s tiene %zu caracteres", original, strlen(original));
    char *d = NULL;

    if (asprintf(&d, "pid %d", 1532) < 0)
        d = NULL;
    if (a == NULL || b == NULL || c == NULL || d == NULL) {
        fprintf(stderr, "sin memoria\n");
        return 1;
    }

    original[0] = 'X';                    /* las copias son independientes */
    printf("original: %s\n", original);
    printf("copiar:   %s\n", a);
    printf("strdup:   %s\n", b);
    printf("formato:  %s\n", c);
    printf("asprintf: %s\n", d);
    free(a);
    free(b);
    free(c);
    free(d);
    return 0;
}

$ ./cadenas
original: Xproc/self/maps
copiar:   /proc/self/maps
strdup:   /proc/self/maps
formato:  /proc/self/maps tiene 15 caracteres
asprintf: pid 1532

• copiar hace lo que strdup: mide con strlen, suma uno para el \0 (el «+ 1» que se olvida es el error más común de las copias de cadenas, el del tema 21), reserva y copia con memcpy. strdup, de string.h, es de POSIX: con -std=c17 necesita #define _POSIX_C_SOURCE 200809L, como explicó el tema 14. Existe también strndup, que copia como máximo n caracteres y siempre termina la cadena.
• formato usa la medición del tema 22. Una primera llamada a vsnprintf con tamaño 0 devuelve cuántos caracteres hacen falta, sin escribir nada; con eso se reserva el bloque exacto, y una segunda llamada escribe. Como la lista de argumentos variables, del tema 11, se recorre dos veces, hace falta va_copy para tener una segunda copia. Es el esquema de las funciones de reserva automática.
• asprintf hace lo mismo ya hecho: es una extensión de GNU, también presente en BSD, que recibe la dirección de un puntero y le asigna el bloque reservado. No es del estándar de C, así que necesita _GNU_SOURCE; si falla, el contenido del puntero queda indefinido, por eso el programa lo pone en NULL.
• Cada resultado debe liberarse, y los cuatro se liberan con el mismo free. No importa quién los creó: lo que importa es que vienen de malloc. Modificar el original no cambió las copias.

8. De quién es cada bloque

En C, el lenguaje no sabe quién es el dueño de un bloque. La pregunta «¿quién lo libera?» se responde por convención, y la respuesta tiene que estar escrita en la documentación de cada función. Es la información más importante de una interfaz que maneja memoria, y la que más errores causa cuando falta. Casi todas las funciones que ya usamos caen en uno de tres casos:

#define _XOPEN_SOURCE 700                 /* realpath es de XSI */
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main(void)
{
    char *dir = getcwd(NULL, 0);          /* POSIX: reserva el lugar necesario */
    char *real = realpath("..", NULL);    /* idem: quien llama libera */
    char *linea = NULL;
    size_t capacidad = 0;
    FILE *f = fopen("/proc/self/status", "r");

    printf("getcwd:   %s\n", dir);
    printf("realpath: %s\n", real);
    if (f != NULL && getline(&linea, &capacidad, f) > 0)
        printf("getline:  %s", linea);
    printf("(la línea ocupó %zu bytes de memoria dinámica)\n", capacidad);

    free(dir);
    free(real);
    free(linea);
    if (f != NULL)
        fclose(f);
    return 0;
}

$ ./duenos
getcwd:   /home/ana/c/tema28
realpath: /home/ana/c
getline:  Name:	duenos
(la línea ocupó 120 bytes de memoria dinámica)

Tres funciones, tres bloques que son del programa. getcwd(NULL, 0) y realpath(…, NULL) son extensiones de POSIX que, ante un buffer nulo, reservan lo que haga falta; evitan adivinar el tamaño con PATH_MAX, un límite que en Linux no es real. getline, vista en el tema 10, es la misma idea con un detalle: recibe la dirección del puntero y la de la capacidad, y los actualiza. Al llamarla en un bucle, el mismo buffer se reutiliza y solo se agranda si una línea no cabe; se libera una vez, al final. Reservó 120 bytes aunque la línea fuera mucho más corta, porque pide un lugar inicial generoso.

Con las estructuras aparece una pregunta más: una estructura que contiene punteros a bloques propios, como el nombre de contador_t en la sección siguiente, posee esos bloques, y quien destruye la estructura debe liberarlos. La regla general para no perderse:

• Un bloque tiene un solo dueño en cada momento, que es quien lo libera. El dueño puede cambiar, si se documenta («esta función toma posesión del bloque»), pero no puede haber dos.
• Quien reserva, libera, cuando el bloque no sale de su función; y el que crea una estructura, la destruye con una función hermana: crear y destruir, abrir y cerrar, fopen y fclose.
• Se libera en el orden inverso al de la creación, primero lo que cuelga y después el contenedor; si se libera el contenedor primero, se pierde el acceso a lo que cuelga.
• Los caminos de error también liberan. Si un programa reserva tres bloques y el tercero falla, debe liberar los dos primeros antes de salir; el patrón con goto limpiar de la sección 10 lo hace en un solo lugar.

9. Un módulo con tipo opaco

En el tema 26 vimos los tipos opacos y quedó pendiente un ejemplo con memoria dinámica, porque quien usa un tipo opaco no puede declarar variables de ese tipo, y solo recibe punteros que el módulo reserva. Este módulo guarda un contador con un nombre propio, en tres archivos:

#ifndef CONTADOR_H
#define CONTADOR_H

#include <stddef.h>

/* tipo opaco: quien incluye este archivo no ve los campos */
typedef struct contador contador_t;

/* reserva un contador con un nombre propio; NULL si no hay memoria */
contador_t *contador_crear(const char *nombre);

/* suma 1 y devuelve el valor nuevo */
long contador_incrementar(contador_t *c);

/* el nombre, que sigue siendo del contador: no se libera ni se guarda */
const char *contador_nombre(const contador_t *c);

/* libera el contador y su nombre; acepta NULL, como free */
void contador_destruir(contador_t *c);

#endif

#define _POSIX_C_SOURCE 200809L           /* strdup */
#include <stdlib.h>
#include <string.h>
#include "contador.h"

struct contador {
    char *nombre;                         /* memoria propia, copiada de la que recibió */
    long valor;
};

contador_t *contador_crear(const char *nombre)
{
    contador_t *c = malloc(sizeof *c);

    if (c == NULL)
        return NULL;
    c->nombre = strdup(nombre);
    if (c->nombre == NULL) {              /* si falla la segunda, hay que deshacer la primera */
        free(c);
        return NULL;
    }
    c->valor = 0;
    return c;
}

long contador_incrementar(contador_t *c)
{
    return ++c->valor;
}

const char *contador_nombre(const contador_t *c)
{
    return c->nombre;
}

void contador_destruir(contador_t *c)
{
    if (c == NULL)
        return;
    free(c->nombre);                      /* primero lo que cuelga... */
    free(c);                              /* ...y después el contenedor */
}

#include <stdio.h>
#include "contador.h"

int main(void)
{
    char texto[] = "visitas";
    contador_t *c = contador_crear(texto);

    if (c == NULL) {
        fprintf(stderr, "sin memoria\n");
        return 1;
    }
    texto[0] = 'X';                       /* el contador tiene su propia copia */
    contador_incrementar(c);
    contador_incrementar(c);
    printf("%s = %ld\n", contador_nombre(c), contador_incrementar(c));
    contador_destruir(c);
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -g -o uso uso.c contador.c && ./uso
visitas = 3
$ gcc -std=c17 -Wall -Wextra -g -o uso_mal uso_mal.c contador.c
uso_mal.c: In function ‘main’:
uso_mal.c:7:16: error: storage size of ‘copia’ isn’t known
    7 |     contador_t copia;                     /* no se puede: tamaño desconocido */
      |                ^~~~~
uso_mal.c:9:22: error: invalid use of incomplete typedef ‘contador_t’ {aka ‘struct contador’}
    9 |     printf("%ld\n", c->valor);            /* ni mirar adentro */
      |                      ^~

El módulo reúne las ideas de la sección 8. La estructura posee su nombre: contador_crear hace una copia con strdup, de modo que modificar el texto original después (la línea texto[0] = 'X') no afecta al contador. El éxito parcial se deshace: si malloc funciona y strdup falla, la función libera el contador antes de devolver NULL, para no dejar un bloque perdido. Destruir es el inverso de crear, libera primero el nombre y luego la estructura, y acepta NULL como free, lo que simplifica los caminos de error de quien lo usa. El nombre que devuelve contador_nombre no se libera: sigue siendo del contador, y deja de ser válido cuando éste se destruye; quien lo necesite más tiempo debe copiarlo con strdup. Y las dos líneas rechazadas por el compilador en uso_mal.c demuestran la opacidad: ni se puede declarar una variable contador_t, porque su tamaño es desconocido, ni acceder a un campo. Todo pasa por las funciones del módulo, y el módulo puede cambiar su implementación sin que uso.c lo note.

10. Matrices dinámicas

En el tema 23 dejamos pendiente cómo crear una matriz cuyas dimensiones se conocen en tiempo de ejecución. Hay dos formas, y la diferencia es cuántos bloques se piden:

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

/* una sola reserva: un puntero a filas de 'cols' enteros */
static int suma_tipada(size_t filas, size_t cols)
{
    int (*m)[cols] = calloc(filas, sizeof *m);     /* sizeof *m = cols * sizeof(int) */

    if (m == NULL)
        return -1;
    for (size_t i = 0; i < filas; i++)
        for (size_t j = 0; j < cols; j++)
            m[i][j] = (int) (i * cols + j);
    int s = m[filas - 1][cols - 1];
    free(m);                                       /* un solo free */
    return s;
}

/* una reserva por fila: filas + 1 reservas y filas + 1 liberaciones */
static int suma_filas(size_t filas, size_t cols)
{
    int **m = calloc(filas, sizeof *m);
    int s = -1;

    if (m == NULL)
        return -1;
    for (size_t i = 0; i < filas; i++) {
        m[i] = calloc(cols, sizeof **m);
        if (m[i] == NULL)
            goto limpiar;
    }
    for (size_t i = 0; i < filas; i++)
        for (size_t j = 0; j < cols; j++)
            m[i][j] = (int) (i * cols + j);
    s = m[filas - 1][cols - 1];
limpiar:
    for (size_t i = 0; i < filas; i++)
        free(m[i]);                                /* free(NULL) es válido */
    free(m);
    return s;
}

int main(void)
{
    printf("último elemento, una reserva:  %d\n", suma_tipada(1000, 500));
    printf("último elemento, por filas:    %d\n", suma_filas(1000, 500));
    return 0;
}

$ ./matriz
último elemento, una reserva:  499999
último elemento, por filas:    499999

La primera usa un puntero a arreglo con una dimensión variable: sizeof *m es cols * sizeof(int), calculado al ejecutar, así que calloc(filas, sizeof *m) reserva todas las filas juntas y, de paso, con la comprobación del desbordamiento de la sección 4. Es la forma preferible cuando la matriz es rectangular. En la segunda, calloc inicializa los punteros en NULL, lo que permite que el camino de error libere sin saber hasta dónde se había llegado: free(NULL) no hace nada. Cuando hay una sola etiqueta de limpieza, el goto hacia abajo es el modismo de C para centralizar la liberación; es el uso disciplinado del goto para la limpieza de recursos que describió el tema 9.

11. Memoria alineada

malloc devuelve direcciones alineadas a 16 bytes, la alineación de max_align_t, como vimos en el tema 25. Si hace falta más, por ejemplo 64 bytes para que una estructura ocupe una línea de caché, hay dos funciones:

#define _POSIX_C_SOURCE 200809L
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    void *a = malloc(100);
    void *b = aligned_alloc(64, 256);     /* C11: el tamaño debe ser múltiplo de la alineación */
    void *c = NULL;
    int err = posix_memalign(&c, 4096, 10000);      /* POSIX: devuelve el error, no usa errno */

    printf("malloc(100)           %p  (mod 16 = %ju, mod 64 = %ju)\n", a,
           (uintmax_t) ((uintptr_t) a % 16), (uintmax_t) ((uintptr_t) a % 64));
    printf("aligned_alloc(64,256) %p  (mod 64 = %ju)\n", b, (uintmax_t) ((uintptr_t) b % 64));
    printf("posix_memalign(4096)  %p  (mod 4096 = %ju, err = %d)\n", c,
           (uintmax_t) ((uintptr_t) c % 4096), err);
    free(a);
    free(b);
    free(c);                              /* todas se liberan con free */
    return 0;
}

$ ./alineada
malloc(100)           0x5c8bca7d5010  (mod 16 = 0, mod 64 = 16)
aligned_alloc(64,256) 0x5c8bca7d5080  (mod 64 = 0)
posix_memalign(4096)  0x5c8bca7d6000  (mod 4096 = 0, err = 0)

aligned_alloc(alineación, tamaño) es del estándar C11, y exige que el tamaño sea múltiplo de la alineación. posix_memalign(&p, alineación, tamaño) es de POSIX, deja la dirección en p y devuelve 0 o el código de error, sin tocar errno; la alineación debe ser una potencia de 2 y múltiplo de sizeof(void *). Con las dos, el bloque se libera con el free normal. La alineación de 4096 es la de una página, que se pide para memoria que se va a pasar al núcleo o a un dispositivo.

12. Por dentro: un bloque de malloc

Un bloque de malloc no es solo los bytes que se piden. La biblioteca guarda información de administración junto a cada uno, y mirarla explica varias conductas. Este programa pide bloques de distintos tamaños y consulta tres cosas: cuánto es realmente utilizable (malloc_usable_size, una extensión de glibc), la palabra de 8 bytes que hay justo antes del bloque, y la distancia entre un bloque y el anterior:

#define _DEFAULT_SOURCE                   /* malloc_usable_size */
#include <malloc.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* campo() es el de bss.c del tema 27 */
int main(void)
{
    size_t pedidos[] = {1, 8, 24, 25, 40, 100, 1000};
    void *anterior = NULL;

    printf("pedido  usable  encabezado  distancia al bloque anterior\n");
    for (size_t i = 0; i < sizeof pedidos / sizeof pedidos[0]; i++) {
        void *p = malloc(pedidos[i]);
        size_t encabezado = ((size_t *) p)[-1];       /* solo para mirar: no se hace en un programa */

        printf("%6zu  %6zu  0x%-8zx  %s%td\n", pedidos[i], malloc_usable_size(p), encabezado,
               anterior ? "+" : "", anterior ? (char *) p - (char *) anterior : 0);
        anterior = p;                                 /* no se libera: se quiere ver la secuencia */
    }

    void *a = malloc(24);
    printf("\nmalloc(24) -> %p\n", a);
    free(a);
    void *b = malloc(24);
    printf("free y otro malloc(24) -> %p  (%s)\n", b, a == b ? "el mismo bloque" : "otro bloque");
    free(b);

    long antes = campo("VmRSS:");
    enum { CUANTOS = 1000000 };
    void **bloques = malloc(CUANTOS * sizeof *bloques);
    for (long i = 0; i < CUANTOS; i++)
        bloques[i] = malloc(8);
    long despues = campo("VmRSS:");

    printf("\n%d bloques de 8 bytes: %ld KiB de VmRSS, unos %ld bytes por bloque (con el puntero)\n",
           CUANTOS, despues - antes, (despues - antes) * 1024 / CUANTOS);
    for (long i = 0; i < CUANTOS; i++)
        free(bloques[i]);
    free(bloques);
    return 0;
}

$ ./por_dentro
pedido  usable  encabezado  distancia al bloque anterior
     1      24  0x21        0
     8      24  0x21        +32
    24      24  0x21        +32
    25      40  0x31        +32
    40      40  0x31        +48
   100     104  0x71        +48
  1000    1000  0x3f1       +112

malloc(24) -> 0x58494e0b8540
free y otro malloc(24) -> 0x58494e0b8540  (el mismo bloque)

1000000 bloques de 8 bytes: 39296 KiB de VmRSS, unos 40 bytes por bloque (con el puntero)

La salida deja ver cómo está hecho el administrador de glibc, que es el de la mayoría de los Linux:

• Cada bloque lleva un encabezado de 8 bytes antes de la dirección que se entrega. Guarda el tamaño del bloque entero, en múltiplos de 16, y en su bit menos significativo marca si el bloque anterior está en uso: 0x21 es 32 más ese bit, 0x31 es 48, 0x71 es 112, 0x3f1 es 1008. Es lo que lee free para saber cuánto devuelve, y por eso free no necesita recibir el tamaño.
• El tamaño real es el pedido más 8, redondeado hacia arriba a múltiplo de 16, con un mínimo de 32. Los pedidos de 1, 8 y 24 bytes ocupan lo mismo, 32, con 24 utilizables. Un pedido de 25 salta a 48, con 40 utilizables. Por eso malloc_usable_size da más de lo pedido, y usar los bytes de más es un error igual: el programa tiene derecho solo a lo que pidió.
• La distancia entre un bloque y el siguiente es el tamaño del bloque (+32, +48, +112): los bloques se reservan uno a continuación del otro. Es la razón por la que un desborde de un bloque pisa el encabezado del siguiente, lo que explica varios mensajes de free.
• Un bloque recién liberado es el primero en reutilizarse. Después de free, el siguiente malloc del mismo tamaño devolvió exactamente la misma dirección. glibc guarda los bloques liberados de cada tamaño en una pequeña caché por hilo, la tcache, como una pila de la que el último en entrar es el primero en salir. Esto hace rápida la reserva, y también hace que un uso después de liberar sea engañoso: el bloque viejo y el nuevo se superponen en cuanto alguien pide algo del mismo tamaño.
• Los bloques chicos salen caros. Un millón de bloques de 8 bytes ocupó unos 40 bytes cada uno con su puntero: 32 el bloque y 8 el puntero. Cinco veces los 8 bytes de datos, y un millón de llamadas a malloc y a free. Cuando hay muchos objetos chicos, conviene reservar un arreglo de ellos de una vez, o usar una lista que reutilice los bloques.

El programa leyó el encabezado con ((size_t *) p)[-1] solo para mirar; no es un dato que se pueda usar, porque su formato es un detalle interno de glibc que cambia entre versiones y entre bibliotecas, y escribir en él corrompe el administrador. Con gdb se puede mirar lo mismo, y también qué pasa con un bloque cuando se lo libera:

$ gdb -q -batch -ex 'break basico.c:23' -ex 'break basico.c:24' -ex 'run 10' -ex 'p v' -ex 'p *v@10' \
      -ex 'p n * sizeof(*v)' -ex 'x/2gx (long *) v - 2' -ex continue -ex 'p *v@10' \
      -ex 'x/4gx (long *) v - 2' ./basico
Breakpoint 1, main (argc=2, argv=0x7fffffffd8b8) at basico.c:23
23	    free(v);
$1 = (int *) 0x555555559010
$2 = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
$3 = 40
0x555555559000:	0x0000000000000000	0x0000000000000031

Breakpoint 2, main (argc=2, argv=0x7fffffffd8b8) at basico.c:24
24	    return 0;
$4 = {1431655769, 5, 106306542, -770954042, 16, 25, 36, 49, 64, 81}
0x555555559000:	0x0000000000000000	0x0000000000000031
0x555555559010:	0x0000000555555559	0xd20c2cc606561bee

Antes del free, el bloque contiene los diez cuadrados, y la palabra de 8 bytes anterior a él, 0x31, dice que el bloque entero mide 48. Después del free el bloque no se borra: seis de los diez enteros siguen ahí, 16, 25, 36… Pero los primeros 16 bytes, cuatro enteros, ya no son los del programa: el administrador los usó para su propia contabilidad, uno con un puntero al siguiente bloque libre, codificado con la dirección del bloque, y otro con una clave al azar que sirve para detectar la doble liberación, y que es la que produjo el mensaje double free detected in tcache 2 de la sección 6. Es un adelanto del tema siguiente: la memoria liberada sigue siendo legible y a veces parece intacta, y esa es justamente la trampa. En ningún programa correcto se lee un bloque después de liberarlo.

13. Errores frecuentes

14. Resumen

• La memoria dinámica se usa cuando el tamaño se conoce al ejecutar, cuando el dato debe sobrevivir a la función, o cuando es grande o crece. Sale del montículo, y tiene tres pasos: pedir, usar, devolver.
• malloc(n) reserva n bytes sin inicializar y devuelve NULL si no puede; no necesita cast en C. El idioma p = malloc(n * sizeof *p) acompaña los cambios de tipo.
• Todo pedido se comprueba. En Linux, con la configuración por omisión, los pedidos moderados casi nunca fallan, porque la memoria se entrega al tocarla; si falta, el OOM killer mata un proceso. Con ulimit -v se prueban los caminos de error.
• calloc(n, tam) entrega memoria en cero y comprueba que n * tam no se desborde, un error de seguridad clásico con malloc(n * tam). Para bloques grandes es casi gratis, porque el núcleo ya entrega páginas en cero. reallocarray es la versión con comprobación de realloc.
• realloc(p, n) cambia el tamaño conservando el contenido; puede mover el bloque, y el puntero viejo deja de valer. Si falla, el original queda intacto: por eso se usa un puntero temporal y nunca p = realloc(p, n).
• Para crecer un arreglo se duplica su capacidad, llevando cantidad y capacidad por separado: el costo por elemento agregado es constante. Crecer de a uno depende de la suerte del asignador.
• free(p) acepta NULL y exige un puntero que vino de malloc, calloc o realloc, una sola vez. gcc avisa algunos errores al compilar y glibc aborta algunos al ejecutar; muchos no producen ningún mensaje. La memoria liberada no se borra.
• strdup, asprintf, getcwd(NULL, 0) y getline reservan por quien llama, que debe liberar. Con vsnprintf(NULL, 0, …) se mide el texto antes de reservarlo.
• La propiedad de cada bloque se decide por convención y se documenta: un bloque, un dueño; quien crea, destruye; se libera primero lo que cuelga; los caminos de error también limpian.
• Un tipo opaco con funciones crear y destruir oculta la estructura y es la forma de armar módulos con memoria propia. Una matriz dinámica puede ser un solo bloque, con int (*m)[cols], o un bloque por fila.
• aligned_alloc y posix_memalign dan memoria con una alineación mayor, y se liberan con free.
• En glibc, cada bloque lleva un encabezado de 8 bytes con su tamaño, el tamaño real es el pedido más 8 redondeado a múltiplo de 16 con un mínimo de 32, y un bloque liberado se reutiliza de inmediato. Los bloques muy chicos son caros.

15. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Escribe int *crear_serie(size_t n), que devuelva un arreglo dinámico con los primeros n cuadrados, o NULL si no hay memoria. Llámala desde main, muestra los valores y libera el arreglo. Pruébala con ulimit -v para ejecutar el camino de error.
2. Escribe una función char *leer_archivo(const char *ruta, size_t *largo) que lea un archivo entero a un bloque dinámico, agrandándolo con realloc y la estrategia de duplicar, y lo termine con \0. Pruébala con un archivo vacío, con uno de 1 byte y con /proc/self/maps (cuyo tamaño según stat es 0).
3. Corrige este fragmento de manera que no pierda memoria si realloc falla: buf = realloc(buf, tam * 2); if (buf == NULL) return -1;. Verifica tu solución con ulimit -v.
4. Escribe una función char **dividir(const char *texto, char sep, size_t *cantidad) que devuelva un arreglo dinámico de cadenas dinámicas, con los campos del texto separados por sep (incluidos los vacíos), y otra liberar_campos que libere todo. ¿Quién es dueño de cada bloque? Escríbelo en un comentario.
5. Agrega a contador_t una función contador_copiar que devuelva un contador nuevo con el mismo nombre y valor. ¿Qué pasaría si copiara solo la estructura, sin duplicar el nombre?
6. Modifica por_dentro.c para ver cuántos bloques de 32 bytes caben antes de que brk cambie, y compara con la región [heap] de /proc/self/maps. ¿Qué pasa con el encabezado de un bloque grande, de 1 MiB, que malloc obtiene con mmap?
7. Mide con clock_gettime el tiempo de reservar y liberar un millón de bloques de 32 bytes con malloc, frente a reservar un solo arreglo de un millón de estructuras de 32 bytes con calloc. ¿Cuál es la diferencia de memoria (VmRSS) y de tiempo?
8. Escribe una versión de suma_filas en la que una fila falle a propósito (por ejemplo, cuando i == 3), y verifica con valgrind --leak-check=full o con -fsanitize=address que el camino de limpieza libera todo.