calloc en C: ejercicio resuelto con array dinámico inicializado a cero

calloc en C: ejercicio resuelto paso a paso

Si buscas un ejercicio de calloc en C resuelto, aquí tienes la diferencia práctica entre calloc y malloc, y cuándo conviene usar cada una.

La función calloc reserva memoria para un array de n elementos de size bytes cada uno y los inicializa todos a cero, a diferencia de malloc que deja el contenido sin definir.

Firma de calloc

1
void *calloc(size_t n, size_t size);

n — número de elementos.
size — tamaño en bytes de cada elemento.
Devuelve un puntero al bloque reservado, o NULL si falla.

Enunciado

Reserva con calloc un array dinámico de 5 enteros e imprime sus valores iniciales (todos deben ser 0).
Rellénalo con los cuadrados de 1 a 5 e imprímelo.
Libera la memoria con free.
A continuación reserva el mismo array con malloc y observa que los valores iniciales son indefinidos.

Solución en C

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n = 5;

    /* --- calloc: memoria inicializada a cero --- */
    int *arr_calloc = calloc(n, sizeof(int));
    if (arr_calloc == NULL) {
        fprintf(stderr, "Error: calloc fallo\n");
        return 1;
    }

    printf("Valores iniciales con calloc:\n");
    for (int i = 0; i < n; i++) {
        printf("arr_calloc[%d] = %d\n", i, arr_calloc[i]);
    }

    for (int i = 0; i < n; i++) {
        arr_calloc[i] = (i + 1) * (i + 1);
    }

    printf("\nDespues de rellenar:\n");
    for (int i = 0; i < n; i++) {
        printf("arr_calloc[%d] = %d\n", i, arr_calloc[i]);
    }

    free(arr_calloc);

    /* --- malloc: memoria NO inicializada --- */
    int *arr_malloc = malloc(n * sizeof(int));
    if (arr_malloc == NULL) {
        fprintf(stderr, "Error: malloc fallo\n");
        return 1;
    }

    printf("\nValores iniciales con malloc (indefinidos):\n");
    for (int i = 0; i < n; i++) {
        printf("arr_malloc[%d] = %d\n", i, arr_malloc[i]);
    }

    free(arr_malloc);
    return 0;
}

Resultado esperado

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
Valores iniciales con calloc:
arr_calloc[0] = 0
arr_calloc[1] = 0
arr_calloc[2] = 0
arr_calloc[3] = 0
arr_calloc[4] = 0

Despues de rellenar:
arr_calloc[0] = 1
arr_calloc[1] = 4
arr_calloc[2] = 9
arr_calloc[3] = 16
arr_calloc[4] = 25

Valores iniciales con malloc (indefinidos):
arr_malloc[0] = <valor_basura>
...

malloc vs calloc vs realloc

Función	Inicializa a 0	Redimensiona	Uso típico
`malloc(n)`	No	No	buffer temporal, estructura única
`calloc(n, size)`	Sí	No	arrays donde el cero es válido
`realloc(ptr, n)`	No	Sí	arrays que crecen dinámicamente

Errores frecuentes

No comprobar si calloc devuelve NULL (fallo de memoria).
Olvidar free y provocar una fuga de memoria.
Asumir que malloc inicializa a cero: nunca lo garantiza.
Pasar los parámetros en orden incorrecto: primero n (cantidad), luego size (tamaño por elemento).

Aplicación práctica

calloc es preferible a malloc cuando:

el valor inicial cero tiene significado (contadores, matrices vacías, buffers de bytes),
se quiere evitar leer basura accidentalmente durante el desarrollo.

Siguiente ejercicio recomendado

Práctica guiada y siguiente paso

Si quieres una ruta completa con progresión real de dificultad:

FAQ

¿`calloc` es más lento que `malloc`?

En la mayoría de sistemas calloc puede ser tan rápido o incluso más rápido que malloc + memset porque el sistema operativo puede entregar páginas ya puestas a cero. En la práctica la diferencia es negligible para arrays pequeños.

¿Puedo usar `realloc` con memoria reservada con `calloc`?

Sí. realloc funciona con cualquier puntero obtenido de malloc, calloc o una llamada anterior a realloc. El bloque nuevo no está inicializado a cero.

¿Cuándo es obligatorio usar `calloc`?

Cuando el código asume que los elementos del array valen cero antes de escribirlos. Si siempre vas a escribir antes de leer, malloc basta.