C Academy · Lección

Punteros colgantes

Peligros del uso tras liberar

Lección 4 de 413 pasos

Punteros colgantes es una lección gratuita de C Academy en CoddyKit. Esta es la lección 4 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 un puntero colgante

Un puntero colgante apunta a memoria que ya se liberó o que, por algún otro motivo, ya no es válida.

Usarlo provoca un comportamiento indefinido: fallos, corrupción de memoria o errores silenciosos.

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

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

Uso después de liberar

La causa más común es leer o escribir mediante un puntero después de llamar a free.

El bloque puede haberse reutilizado para otra cosa.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 42;
    free(p);
    /* Reading *p here would be use-after-free. */
    p = NULL;
    printf("avoided use-after-free\n");
    return 0;
}

Asignar NULL después de liberar

Asignar NULL a un puntero justo después de liberar la memoria convierte un uso accidental en un fallo claro o en una llamada inofensiva a free(NULL).

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

int main(void) {
    char *buf = malloc(10);
    buf[0] = 'A';
    free(buf);
    buf = NULL;
    if (buf == NULL) printf("buf is safely null\n");
    return 0;
}

Devolver una dirección local

Devolver la dirección de una variable local (de la pila) crea un puntero colgante: la variable desaparece cuando la función retorna.

Use el heap o pase un búfer como argumento.

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

int *make_value(int v) {
    int *p = malloc(sizeof(int));
    *p = v;
    return p;
}

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

Varios punteros a un bloque

Si dos punteros hacen referencia al mismo bloque, liberar la memoria mediante uno hace que el otro quede colgante.

Realice un seguimiento de la propiedad para que solo el propietario libere la memoria.

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

int main(void) {
    int *a = malloc(sizeof(int));
    *a = 7;
    int *b = a;
    printf("%d\n", *b);
    free(a);
    a = NULL;
    b = NULL;
    printf("both nulled\n");
    return 0;
}

Puntero colgante después de realloc

Cuando realloc mueve un bloque, cualquier puntero antiguo a la ubicación anterior se convierte en un puntero colgante.

Use únicamente el puntero que devolvió realloc.

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

int main(void) {
    int *a = malloc(sizeof(int));
    a[0] = 1;
    int *b = realloc(a, 50 * sizeof(int));
    /* a may now be dangling; use only b. */
    b[0] = 2;
    printf("%d\n", b[0]);
    free(b);
    return 0;
}

Liberar memoria en una función auxiliar

Si una función auxiliar libera un bloque, el puntero del código llamador queda colgante. Asígnele NULL después de la llamada o diseñe la función auxiliar para que reciba un puntero a puntero.

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

void destroy(int **p) {
    free(*p);
    *p = NULL;
}

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 5;
    destroy(&p);
    printf("p is %s\n", p == NULL ? "null" : "set");
    return 0;
}

Por qué es peligroso

El uso después de liberar memoria es peligroso porque la memoria puede contener ahora otros datos. Las escrituras pueden corromper estados no relacionados y los atacantes pueden aprovechar esta vulnerabilidad.

Punteros colgantes por ámbito

Un puntero a una variable cuyo ámbito está limitado a un bloque deja de ser válido cuando termina dicho bloque. Mantenga los punteros como máximo durante la vida útil de aquello a lo que apuntan.

#include <stdio.h>

int main(void) {
    int *p;
    {
        int x = 10;
        p = &x;
        printf("in scope: %d\n", *p);
    }
    /* p now dangles; do not dereference it here. */
    printf("block ended\n");
    return 0;
}

Detectar punteros colgantes

Herramientas como AddressSanitizer y Valgrind detectan el uso después de liberar memoria durante la ejecución y señalan la línea exacta.

Compile con sanitizers durante el desarrollo.

Resumen del ciclo de vida seguro en código

Asigne memoria, úsela, libérela y asigne NULL. Seguir este proceso de forma sistemática evita que los punteros queden colgantes.

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

int main(void) {
    int *p = malloc(sizeof(int));
    if (!p) return 1;
    *p = 123;
    printf("%d\n", *p);
    free(p);
    p = NULL;
    return 0;
}

Comprobación rápida

Compruebe su comprensión de los punteros colgantes.

Responde en la lección interactiva

Resumen

Ha aprendido sobre los punteros colgantes:

Apuntan a memoria liberada o fuera de ámbito; usarlos provoca un comportamiento indefinido.
Evite devolver direcciones de variables locales; nunca use un puntero después de free ni después de que realloc mueva un bloque.
Asigne NULL a los punteros después de liberar la memoria y realice un seguimiento de la propiedad.
Use sanitizers y Valgrind para detectar el uso después de liberar memoria.

Gratis para empezar

Aprende C con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 39
Lecciones: 144

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Punteros colgantes» es gratis?

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

Peligros del uso tras liberar 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 4 de 4.

¿Cuánto tiempo toma la lección «Punteros colgantes»?

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