C++ Academy · Lección

Errores habituales de memoria

Evite fugas y punteros colgantes

Errores habituales de memoria 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.

Fugas de memoria

Se produce una fuga de memoria cuando se asigna memoria en el montón, pero nunca se libera. El programa sigue consumiendo memoria a la que ya no puede acceder.

void leak() {
    int* p = new int(5);
    // missing delete p;  -> leaked
}

Punteros colgantes

Un puntero colgante apunta a memoria que ya se ha liberado. Desreferenciarlo produce un comportamiento indefinido.

int* p = new int(7);
delete p;
// *p = 3;   // BUG: dangling access

Doble liberación

Llamar dos veces a delete sobre el mismo puntero corrompe el montón y a menudo provoca que el programa se bloquee.

int* p = new int(1);
delete p;
// delete p;   // BUG: double free

Uso después de liberar

Leer o escribir mediante un puntero después de eliminar el objeto es un caso de uso después de liberar, una fuente común de vulnerabilidades de seguridad.

Desbordamiento de búfer

Escribir más allá del final de una matriz sobrescribe memoria no relacionada. Manténgase siempre dentro de los límites.

int a[3] = {1, 2, 3};
// a[3] = 99;   // BUG: out of bounds

delete no coincidente

Usar delete con una asignación realizada mediante new[] (o al revés) produce un comportamiento indefinido. Manténgalos emparejados.

int* arr = new int[4];
// delete arr;   // BUG: should be delete[] arr;
delete[] arr;     // correct

Punteros no inicializados

Un puntero no inicializado contiene basura. Inicialícelo siempre con una dirección válida o con nullptr.

#include <iostream>

int main() {
    int* p = nullptr;   // safe default
    if (!p) std::cout << "not set\n";
}

Devolver direcciones locales

Devolver la dirección de una variable local de la pila crea inmediatamente un puntero colgante, ya que la variable local muere al retornar.

int* bad() {
    int x = 10;
    return &x;   // BUG: x is gone
}

Los punteros inteligentes evitan fugas

Sustituir los propietarios basados en punteros sin procesar por std::unique_ptr elimina la mayoría de las fugas y las dobles liberaciones: la limpieza es automática y única.

#include <iostream>
#include <memory>

int main() {
    auto p = std::make_unique<int>(5);
    std::cout << *p << "\n";
}   // freed exactly once, automatically

Herramientas para detectar errores

Herramientas como AddressSanitizer y Valgrind detectan en tiempo de ejecución fugas, dobles liberaciones y accesos fuera de los límites. Inclúyalas en sus pruebas.

Prevenir es mejor que detectar

La mejor solución es evitar por completo la propiedad mediante punteros sin procesar: use contenedores como std::vector y punteros inteligentes para que la biblioteca administre correctamente la memoria por usted.

Comprobación rápida

Compruebe su comprensión de los errores de memoria.

Resumen

Ha aprendido los errores clásicos de memoria: fugas, punteros colgantes, doble liberación, uso después de liberar, desbordamientos de búfer y delete no coincidentes. Prevéngalos con punteros inteligentes y contenedores, y detecte los demás con sanitizadores y Valgrind.

Preguntas frecuentes

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

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

Evite fugas y punteros colgantes 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 «Errores habituales 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