Docs ejecutables de C: calloc y realloc

Q: ¿Cuál es la diferencia entre calloc y malloc en C?

Dos diferencias. calloc(n, size) recibe la cantidad y el tamaño de cada elemento por separado y comprueba que multiplicarlos no desborde, mientras que malloc(n * size) puede dar la vuelta en silencio. Y calloc rellena el bloque con ceros, mientras que malloc lo deja con lo que hubiera antes.

Q: ¿Cómo funciona realloc en C?

realloc(p, newsize) devuelve un bloque del nuevo tamaño con tu contenido actual conservado hasta el menor de los dos tamaños. Puede agrandar el bloque en su sitio o moverlo, así que el puntero devuelto es el único que puedes seguir usando: el antiguo quizá ya fue liberado.

Q: ¿Por qué hay que asignar realloc a un puntero temporal?

Porque p = realloc(p, n) sobrescribe p con NULL cuando la llamada falla, y el bloque original sigue reservado sin que nada apunte a él: una fuga. Asigna primero a un tmp, comprueba si es NULL y solo entonces escribe p = tmp.

malloc responde una sola pregunta: dame esta cantidad de bytes. Dos compañeras en <stdlib.h> responden las preguntas que vienen después: dame esta cantidad de bytes, limpios (calloc) y necesito que el bloque que ya tengo sea más grande (realloc).

calloc: cantidad, tamaño y ceros

void *calloc(size_t count, size_t size);

Dos argumentos en lugar de uno, y el resultado queda lleno de bytes en cero.

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

int main(void) {
    size_t n = 6;

    int *counts = calloc(n, sizeof *counts);
    if (counts == NULL) {
        fprintf(stderr, "sin memoria\n");
        return 1;
    }

    /* ya están en cero: no hace falta un bucle de inicialización */
    for (size_t i = 0; i < n; i++) {
        printf("%d ", counts[i]);
    }
    printf("\n");

    counts[2] += 1;
    counts[2] += 1;
    printf("counts[2] = %d\n", counts[2]);

    free(counts);
    return 0;
}

Ese es el caso clásico: un histograma o un array de conteos donde cada casilla debe empezar en cero. Con malloc necesitarías un bucle; calloc lo hace como parte de la reserva, muchas veces sin costo porque el sistema operativo ya entrega páginas nuevas previamente puestas en cero.

El argumento del desbordamiento

La división en dos argumentos no es cosmética. Piensa en una cantidad leída de un archivo:

size_t n = huge_value_from_input;

int *a = malloc(n * sizeof *a);     /* el producto puede dar la vuelta */
int *b = calloc(n, sizeof *b);      /* obligada a detectar el desbordamiento */

Si n * sizeof *a supera lo que size_t puede contener, da la vuelta a un número pequeño, malloc tiene éxito con un bloque diminuto y cada escritura posterior se va muy por delante del final. El estándar obliga a calloc a fallar y devolver NULL en su lugar. Cuando un tamaño viene de fuera de tu programa, esa comprobación vale la pena.

Qué significa realmente "en cero"

calloc escribe bytes en cero. Para enteros y caracteres eso es el valor cero, que es lo que quieres. Para punteros y valores de punto flotante, todos los bits en cero equivalen a un puntero nulo y a 0.0 en toda plataforma habitual, pero el estándar de C no lo promete. El código que debe ser estrictamente portable los asigna de forma explícita.

calloc frente a malloc + memset

int *a = calloc(n, sizeof *a);

int *b = malloc(n * sizeof *b);
if (b != NULL) {
    memset(b, 0, n * sizeof *b);
}

Producen el mismo resultado. Prefiere calloc: es una sola línea, hace la comprobación de desbordamiento y, para bloques grandes, puede evitar tocar la memoria por completo. Prefiere malloc a secas cuando de todas formas vas a sobrescribir cada byte: poner en cero un megabyte que vas a llenar de inmediato es puro desperdicio.

realloc: cambiar el tamaño

void *realloc(void *p, size_t newsize);

realloc devuelve un bloque de newsize bytes cuyo contenido coincide con el bloque antiguo hasta el menor de los dos tamaños. Puede extender el bloque donde está, o reservar uno nuevo, copiar y liberar el viejo. No puedes saber cuál de las dos cosas hizo, así que el único puntero que puedes usar después es el que devolvió.

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

int main(void) {
    size_t n = 3;
    int *a = malloc(n * sizeof *a);
    if (a == NULL) {
        return 1;
    }
    for (size_t i = 0; i < n; i++) {
        a[i] = (int)i;
    }

    size_t bigger = 6;
    int *tmp = realloc(a, bigger * sizeof *a);
    if (tmp == NULL) {
        free(a);                 /* a sigue siendo válido: libéralo */
        fprintf(stderr, "no se pudo agrandar\n");
        return 1;
    }
    a = tmp;

    /* los 3 primeros valores sobrevivieron; las casillas nuevas no están inicializadas */
    for (size_t i = n; i < bigger; i++) {
        a[i] = (int)(i * 10);
    }

    for (size_t i = 0; i < bigger; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");

    free(a);
    return 0;
}

El modismo del puntero tmp

Las tres líneas alrededor de tmp son toda la razón por la que esta función tiene mala fama. El atajo tentador está roto:

/* BUG: fuga el bloque original cuando realloc falla */
p = realloc(p, newsize);
if (p == NULL) {
    return;
}

Cuando realloc falla devuelve NULL y deja el bloque original reservado y sin cambios. Asignar el resultado directamente a p sobrescribe el único puntero a ese bloque, así que nunca podrá liberarse: una fuga, y una que ocurre justo cuando la memoria ya escasea. Asigna a tmp, comprueba tmp y luego confirma:

void *tmp = realloc(p, newsize);
if (tmp == NULL) {
    /* p sigue siendo válido; maneja el fallo como convenga a quien llama */
    return 0;
}
p = tmp;

Dos comportamientos más que conviene conocer: realloc(NULL, n) se comporta exactamente como malloc(n), lo que permite que una función de crecimiento maneje su primera llamada sin un caso especial. Y al agrandar, los bytes nuevos quedan sin inicializar: solo se conserva el contenido antiguo.

Hacer crecer un array: el patrón estándar

Este es el patrón que usa casi todo contenedor en C: una longitud, una capacidad y duplicar cuando se encuentran.

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

struct IntVec {
    int   *data;
    size_t len;
    size_t cap;
};

/* devuelve 1 si tuvo éxito, 0 si el array no pudo crecer */
int vec_push(struct IntVec *v, int value) {
    if (v->len == v->cap) {
        size_t newcap = (v->cap == 0) ? 4 : v->cap * 2;

        int *tmp = realloc(v->data, newcap * sizeof *v->data);
        if (tmp == NULL) {
            return 0;               /* v->data queda intacto y sigue siendo válido */
        }
        v->data = tmp;
        v->cap  = newcap;
    }

    v->data[v->len++] = value;
    return 1;
}

int main(void) {
    struct IntVec v = {NULL, 0, 0};

    for (int i = 1; i <= 10; i++) {
        if (!vec_push(&v, i * i)) {
            fprintf(stderr, "sin memoria en %d\n", i);
            free(v.data);
            return 1;
        }
    }

    printf("len = %zu, cap = %zu\n", v.len, v.cap);
    for (size_t i = 0; i < v.len; i++) {
        printf("%d ", v.data[i]);
    }
    printf("\n");

    free(v.data);
    v.data = NULL;
    v.len = v.cap = 0;
    return 0;
}

Dos decisiones de diseño cargan con todo el peso aquí.

Duplicar, no sumar uno. Crecer en una cantidad fija hace que cada inserción copie el array entero, así que llenar n elementos cuesta aproximadamente n² copias de bytes. Duplicar hace que las copias sean lo bastante raras como para que cada inserción cueste tiempo constante en promedio. El arranque cap == 0 ? 4 : cap * 2 maneja la primera inserción sin una rama aparte, porque realloc(NULL, n) es simplemente malloc.

El struct es dueño de una sola reserva. v.data se libera exactamente una vez, por quien sea dueño del struct. Dejar esa regla de propiedad por escrito (en un comentario, o emparejando cada vec_init con un vec_free) es lo que evita que un contenedor que crece tenga fugas mientras pasa entre funciones.

Encoger

realloc con un tamaño menor recorta un bloque, lo cual resulta útil después de haber leído una cantidad desconocida de datos en un búfer sobredimensionado:

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

int main(void) {
    size_t cap = 1024;
    char *buf = malloc(cap);
    if (buf == NULL) {
        return 1;
    }

    const char *text = "solo unos pocos bytes";
    size_t used = 0;
    while (text[used] != '\0' && used < cap - 1) {
        buf[used] = text[used];
        used++;
    }
    buf[used] = '\0';

    char *tmp = realloc(buf, used + 1);
    if (tmp != NULL) {
        buf = tmp;               /* el encogimiento funcionó */
    }
    /* si falló, buf sigue siendo el bloque grande: perfectamente usable */

    printf("[%s] ahora mide %zu\n", buf, used + 1);

    free(buf);
    return 0;
}

Un encogimiento fallido no es un error por el que valga la pena abortar: el bloque antiguo, más grande, sigue siendo válido y sigue siendo correcto. Este es el único caso donde ignorar el fallo es la decisión correcta, pero fíjate en que igual pasa por tmp, porque la regla de no sobrescribir el puntero vivo no cambia.

Cuál elegir

Lo que quieres	Usa
Bytes, sin importar el contenido	`malloc(n * sizeof *p)`
Una cantidad de elementos, puestos en cero	`calloc(n, sizeof *p)`
Una cantidad que viene de una fuente no confiable	`calloc`, por la comprobación de desbordamiento
El bloque que ya tienes, más grande o más chico	`realloc` a través de un puntero `tmp`
La primera reserva en un bucle de crecimiento	`realloc(NULL, n)`: sin caso especial

Las cuatro se liberan con el mismo free, exactamente una vez.

Errores comunes

p = realloc(p, n): fuga cuando falla. Pasa siempre por tmp.
Guardar un puntero antiguo al bloque. Después de realloc los datos pueden haberse movido, así que todo puntero interior guardado o dirección derivada de un índice queda obsoleto. Los índices sobreviven a una mudanza; los punteros no.
Suponer que los bytes nuevos están en cero. Solo calloc pone ceros. realloc deja la zona de crecimiento sin inicializar.
calloc(n * size, 1): eso tira a la basura la comprobación de desbordamiento para la que existe la forma de dos argumentos.
Liberar el puntero antiguo tras un realloc exitoso. realloc ya lo liberó; un segundo free es una doble liberación.

Preguntas frecuentes

¿Cuál es la diferencia entre calloc y malloc en C?

Dos diferencias. calloc(n, size) recibe la cantidad y el tamaño de cada elemento por separado y comprueba que multiplicarlos no desborde, mientras que malloc(n * size) puede dar la vuelta en silencio. Y calloc rellena el bloque con ceros, mientras que malloc lo deja con lo que hubiera antes.

¿Cómo funciona realloc en C?

realloc(p, newsize) devuelve un bloque del nuevo tamaño con tu contenido actual conservado hasta el menor de los dos tamaños. Puede agrandar el bloque en su sitio o moverlo, así que el puntero devuelto es el único que puedes seguir usando: el antiguo quizá ya fue liberado.

¿Por qué hay que asignar realloc a un puntero temporal?

Porque p = realloc(p, n) sobrescribe p con NULL cuando la llamada falla, y el bloque original sigue reservado sin que nada apunte a él: una fuga. Asigna primero a un tmp, comprueba si es NULL y solo entonces escribe p = tmp.

¿Cuándo debo usar calloc en lugar de malloc?

Cuando realmente necesitas la memoria en cero (un array de contadores, un struct cuyos campos deben empezar vacíos, un búfer que llenarás parcialmente) o cuando el tamaño es una cantidad por un tamaño de elemento que podría ser grande. Si de todos modos vas a sobrescribir cada byte, malloc te ahorra el trabajo de poner ceros.

Conceptos relacionados