C++ Academy · Lección

Asignación en el heap con new/delete

Gestione la memoria dinámica

Asignación en el heap con new/delete es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 2 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.

Memoria dinámica con new

El operador new asigna un objeto en el montón (almacenamiento libre) y devuelve un puntero a él. Los objetos del montón permanecen hasta que los libera explícitamente.

#include <iostream>

int main() {
    int* p = new int(42);   // heap allocation
    std::cout << *p << "\n";
    delete p;               // release it
}

Liberación con delete

Cada new debe corresponderse exactamente con un delete. Si lo olvida, se produce una fuga de memoria; si lo hace dos veces, se corrompe el montón.

#include <iostream>

int main() {
    double* d = new double(3.5);
    std::cout << *d << "\n";
    delete d;     // exactly once
}

Matrices: new[] y delete[]

Para las matrices, use new[] y el delete[] correspondiente. Mezclar new[] con un delete normal produce un comportamiento indefinido.

#include <iostream>

int main() {
    int* arr = new int[3]{1, 2, 3};
    for (int i = 0; i < 3; ++i) std::cout << arr[i] << "\n";
    delete[] arr;   // note the [ ]
}

Por qué usar el montón

Use el montón cuando un objeto deba sobrevivir a la función que lo creó o cuando su tamaño solo se conozca en tiempo de ejecución. En los demás casos, prefiera la pila.

El ciclo de vida del montón es manual

A diferencia de la pila, el montón no libera objetos automáticamente. Usted controla exactamente cuándo se libera la memoria y es responsable de hacerlo.

#include <iostream>

int* makeCounter() {
    return new int(0);   // survives the function
}

int main() {
    int* c = makeCounter();
    std::cout << *c << "\n";
    delete c;
}

Establezca los punteros en nullptr después de delete

Después de eliminar un objeto, establezca el puntero en nullptr para que una reutilización accidental falle de forma evidente en lugar de acceder a memoria liberada.

#include <iostream>

int main() {
    int* p = new int(9);
    delete p;
    p = nullptr;     // now p is safe to check
    if (!p) std::cout << "freed\n";
}

La asignación puede fallar

Si el sistema se queda sin memoria, new lanza std::bad_alloc. En asignaciones muy grandes, esto es una posibilidad real.

Búferes de tamaño en tiempo de ejecución

Las matrices del montón pueden usar un tamaño calculado en tiempo de ejecución, algo que las matrices de la pila no pueden hacer de forma portable.

#include <iostream>

int main() {
    int n = 5;
    int* buf = new int[n];
    for (int i = 0; i < n; ++i) buf[i] = i * i;
    std::cout << buf[4] << "\n";
    delete[] buf;
}

Prefiera los punteros inteligentes

El C++ moderno evita el uso directo de new/delete. std::unique_ptr y std::make_unique liberan la memoria automáticamente cuando el puntero sale del ámbito.

#include <iostream>
#include <memory>

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

El coste del montón

La asignación en el montón es más lenta que en la pila: busca un bloque libre y actualiza la información de gestión. Las asignaciones pequeñas y frecuentes pueden perjudicar el rendimiento.

Haga corresponder cada new

La regla de oro: cada new necesita un delete y cada new[] necesita un delete[]. Mejor aún, deje que los punteros inteligentes se encarguen de ello.

Comprobación rápida

Compruebe su comprensión de la asignación en el montón.

Resumen

Ha aprendido a asignar memoria en el montón con new/new[] y a liberarla con delete/delete[]. Los objetos del montón sobreviven a su ámbito, pero requieren una limpieza manual. Haga corresponder cada asignación, establezca en nulo los punteros cuya memoria haya liberado y prefiera std::unique_ptr en el código moderno.

Preguntas frecuentes

¿La lección «Asignación en el heap con new/delete» es gratis?

Sí — el texto completo de «Asignación en el heap con new/delete» 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 «Asignación en el heap con new/delete»?

Gestione la memoria dinámica 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 2 de 4.

¿Cuánto tiempo toma la lección «Asignación en el heap con new/delete»?

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