C Academy · Lección

Fugas de memoria

Encuentre y evite fugas

Fugas de memoria es una lección gratuita de C Academy en CoddyKit. Esta es la lección 3 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.

Qué es una fuga de memoria

Se produce una fuga de memoria cuando asigna memoria del heap, pero nunca la libera y pierde el único puntero que apunta a ella.

La memoria permanece reservada hasta que termina el programa, desperdiciando recursos.

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

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

Perder el puntero

La fuga clásica consiste en sobrescribir un puntero con una nueva asignación antes de liberar la anterior.

El primer bloque se vuelve inaccesible.

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

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

Fugas en bucles

Asignar memoria dentro de un bucle sin liberarla en cada iteración multiplica rápidamente la fuga.

La solución es liberar la memoria antes de que la siguiente iteración sobrescriba el puntero.

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

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

Los retornos anticipados provocan fugas

Un return anticipado después de una asignación puede omitir la limpieza. Libere siempre la memoria en todas las rutas de salida.

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

int process(int bad) {
    int *p = malloc(sizeof(int));
    if (bad) {
        free(p);
        return -1;
    }
    *p = 42;
    int r = *p;
    free(p);
    return r;
}

int main(void) {
    printf("%d\n", process(0));
    return 0;
}

Patrón de limpieza con goto

Una única etiqueta de limpieza a la que se llega mediante goto garantiza que exista un solo lugar donde liberar todo, evitando llamadas free duplicadas.

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

int main(void) {
    int rc = 1;
    int *p = malloc(sizeof(int));
    if (!p) goto done;
    *p = 7;
    printf("%d\n", *p);
    rc = 0;
done:
    free(p);
    return rc;
}

Hacer coincidir cada asignación

La regla más sencilla: por cada malloc, calloc o realloc, debe haber exactamente un free correspondiente.

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

int main(void) {
    char *a = malloc(8);
    char *b = calloc(4, sizeof(char));
    a[0] = 'x';
    printf("%c %d\n", a[0], b[0]);
    free(a);
    free(b);
    return 0;
}

Liberar asignaciones anidadas

Si una estructura posee memoria del heap, libere los punteros internos antes de liberar el bloque externo.

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

typedef struct {
    int *data;
} Box;

int main(void) {
    Box *b = malloc(sizeof(Box));
    b->data = malloc(3 * sizeof(int));
    b->data[0] = 1;
    printf("%d\n", b->data[0]);
    free(b->data);
    free(b);
    return 0;
}

Liberar un array de punteros

Cuando asigne un array de punteros y cada entrada sea una asignación independiente, libere primero todas las entradas y después el array.

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

int main(void) {
    int n = 3;
    int **rows = malloc(n * sizeof(int *));
    for (int i = 0; i < n; i++) {
        rows[i] = malloc(2 * sizeof(int));
        rows[i][0] = i;
    }
    for (int i = 0; i < n; i++) free(rows[i]);
    free(rows);
    printf("freed all rows\n");
    return 0;
}

Disciplina de propiedad

Decida quién es el propietario de cada asignación y quién es responsable de liberarla. Documente esta decisión para que los llamadores sepan si deben liberar un puntero devuelto.

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

char *make_greeting(void) {
    char *s = malloc(6);
    s[0]='h'; s[1]='i'; s[2]='\0';
    return s;
}

int main(void) {
    char *g = make_greeting();
    printf("%s\n", g);
    free(g);
    return 0;
}

Herramientas que detectan fugas

Herramientas como Valgrind y AddressSanitizer informan de las fugas mediante el seguimiento de cada asignación y muestran cuáles nunca se liberaron.

Son esenciales para verificar programas reales.

Un ciclo de vida limpio de las asignaciones

En conjunto: asigne, compruebe, use, libere en todas las rutas y establezca el puntero en NULL. Así mantendrá los programas libres de fugas.

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

int main(void) {
    int *p = malloc(4 * sizeof(int));
    if (!p) return 1;
    for (int i = 0; i < 4; i++) p[i] = i + 1;
    int sum = 0;
    for (int i = 0; i < 4; i++) sum += p[i];
    printf("sum = %d\n", sum);
    free(p);
    p = NULL;
    return 0;
}

Comprobación rápida

Compruebe su comprensión de las fugas de memoria.

Resumen

Ha aprendido a evitar fugas de memoria:

Haga coincidir cada asignación con exactamente un free.
Libere la memoria en todas las rutas de salida, incluidos los retornos anticipados y los errores.
Libere primero las asignaciones internas en estructuras anidadas y arrays de punteros.
Defina claramente la propiedad y use herramientas como Valgrind para verificar el código.

Preguntas frecuentes

¿La lección «Fugas de memoria» es gratis?

Sí — el texto completo de «Fugas de memoria» 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 «Fugas de memoria»?

Encuentre y evite fugas 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 3 de 4.

¿Cuánto tiempo toma la lección «Fugas de memoria»?

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