C Academy · Lección

malloc y free

Asigne memoria en el heap

malloc y free es una lección gratuita de C Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C Academy incluye 4 lecciones en total.

El heap

Hasta ahora, las variables vivían en la pila con un tiempo de vida fijo. El heap permite solicitar memoria durante la ejecución y conservarla tanto tiempo como sea necesario.

Debe gestionar la memoria del heap por su cuenta mediante las funciones de <stdlib.h>.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 99;
    printf("%d\n", *p);
    free(p);
    return 0;
}

Llamar a malloc

malloc(size) reserva size bytes y devuelve un puntero a ellos, o NULL si se produce un error.

La memoria está sin inicializar: su contenido es indeterminado.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 7;
    printf("value = %d\n", *p);
    free(p);
    return 0;
}

Dimensionar con sizeof

Dimensione siempre las asignaciones con sizeof para que el código sea correcto en cualquier plataforma.

Escribir sizeof(*p) vincula automáticamente el tamaño al tipo del puntero.

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

int main(void) {
    double *p = malloc(sizeof(*p));
    *p = 3.14;
    printf("%f\n", *p);
    free(p);
    return 0;
}

Compruebe siempre NULL

Si la asignación falla, malloc devuelve NULL. Desreferenciarlo provoca que el programa se bloquee.

Compruebe el resultado antes de usarlo.

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

int main(void) {
    int *p = malloc(sizeof(int));
    if (p == NULL) {
        printf("allocation failed\n");
        return 1;
    }
    *p = 5;
    printf("ok: %d\n", *p);
    free(p);
    return 0;
}

Asignar un array

Para almacenar muchos elementos, multiplique el tamaño de cada elemento por la cantidad.

malloc(n * sizeof(int)) crea espacio para n enteros.

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

int main(void) {
    int n = 5;
    int *arr = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) arr[i] = i * i;
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    free(arr);
    return 0;
}

Los arrays del heap usan indexación mediante punteros

Se accede a un array del heap mediante su puntero, usando la conocida sintaxis arr[i], que equivale a *(arr + i).

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

int main(void) {
    int *arr = malloc(3 * sizeof(int));
    arr[0] = 10;
    *(arr + 1) = 20;
    arr[2] = 30;
    printf("%d %d %d\n", arr[0], arr[1], arr[2]);
    free(arr);
    return 0;
}

Liberar memoria

free(p) devuelve el bloque al asignador. Después de esto, no debe usar p para acceder a esa memoria.

Cada malloc que se complete correctamente necesita un free correspondiente.

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

int main(void) {
    char *buf = malloc(16);
    if (buf) {
        buf[0] = 'A';
        printf("%c\n", buf[0]);
        free(buf);
    }
    return 0;
}

free(NULL) es seguro

Llamar a free con un puntero NULL no hace nada y es completamente válido.

Esto simplifica el código de limpieza que puede ejecutarse antes de que la asignación se complete correctamente.

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

int main(void) {
    int *p = NULL;
    free(p);
    printf("free(NULL) was safe\n");
    return 0;
}

Devolver memoria del heap

A diferencia de las variables de la pila, la memoria del heap sobrevive después de que la función devuelve el control. Esto permite que una función asigne y devuelva un búfer.

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

int *make_range(int n) {
    int *a = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) a[i] = i;
    return a;
}

int main(void) {
    int *r = make_range(4);
    printf("%d %d\n", r[0], r[3]);
    free(r);
    return 0;
}

No convierta malloc en C

En C, malloc devuelve un void * que se convierte automáticamente a cualquier tipo de puntero.

La conversión explícita es innecesaria y puede ocultar la falta de inclusión de <stdlib.h>.

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

int main(void) {
    long *p = malloc(sizeof(long));
    *p = 1234567L;
    printf("%ld\n", *p);
    free(p);
    return 0;
}

No libere dos veces

Llamar a free dos veces con el mismo puntero produce comportamiento indefinido y puede corromper el heap.

Asigne NULL al puntero después de liberarlo para que una reutilización accidental no tenga consecuencias.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 1;
    free(p);
    p = NULL;
    free(p);
    printf("no double free\n");
    return 0;
}

Comprobación rápida

Compruebe sus conocimientos sobre malloc y free.

Resumen

Ha aprendido los conceptos básicos de la asignación en el heap:

malloc(size) reserva bytes sin inicializar y devuelve NULL si se produce un error.
Compruebe siempre el resultado y dimensione la asignación con sizeof.
free(p) devuelve la memoria; cada malloc necesita un free.
free(NULL) es seguro; liberar dos veces produce un comportamiento indefinido.

Preguntas frecuentes

¿La lección «malloc y free» es gratis?

Sí — el texto completo de «malloc y free» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C Academy, actualiza a CoddyKit PRO. El curso de C Academy incluye 4 lecciones en total.

¿Qué aprenderé en «malloc y free»?

Asigne memoria en el heap Practicas C Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C Academy?

No se requiere experiencia previa. C Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «malloc y free»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C Academy?

Sí. Cada lección de C Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C Academy