Asignación Dinámica de Memoria

Hay dos tipos de memoria disponibles para su uso: stack y heap. La memoria stack es limitada en tamaño y es adecuada para variables pequeñas y de corta duración que no se necesitan más allá de su alcance. Cuando una variable almacenada en el stack sale de su alcance, se destruye automáticamente.

stack_allocated


              12
            
// Creates an integer variable on the stack
int stack_int = 42;

Sin embargo, cuando necesitas memoria que persista más allá de su alcance, o que requiera más espacio, recurres al heap. El heap es un pool de memoria mucho más grande donde tu programa puede solicitar memoria en tiempo de ejecución. Esto se hace típicamente usando la palabra clave new:

heap_allocated


              12
            
// create an integer on the heap
int* heap_int = new int;

Lo complicado de la memoria del montón es que no se libera automáticamente. Es responsabilidad del desarrollador desalojarla cuando haya terminado. Por cada new, debe haber un delete correspondiente.

free_pointer


              12
            
// Explicitly deletes the integer on the heap
delete heap_int;

Fugas de Memoria

Cuando introduces punteros en tu código, entras en el ámbito de la gestión manual de memoria. La gestión manual de memoria requiere que liberes la memoria cuando ya no es necesaria. Puede llevar a errores comunes: fugas de memoria y punteros colgantes.

Las fugas de memoria ocurren típicamente cuando olvidas desalojar la memoria. Tal memoria permanece reservada, causando que tu programa pierda memoria con el tiempo.

memory_leak


              12345
            
running = true
while (running)
{
    int* p_int = new int;
}

Punteros Colgantes

Los punteros colgantes ocurren cuando un puntero continúa apuntando a una memoria que ha sido desalojada. Es como tener un mapa del tesoro que te lleva a un lugar (dirección de memoria) donde el tesoro (datos) ya ha sido tomado (destruido).

main


              12345678910111213
            
#include <iostream>

int main()
{
    int* ptr = new int; // dynamically allocate an integer

    *ptr = 42; // assign a value to the allocated memory
    std::cout << *ptr << std::endl; // This will output 42

    delete ptr; // deallocate the memory

    std::cout << *ptr << std::endl; // ptr is a dangling pointer!
}

Intentar acceder a un puntero después de llamar a delete en él, lo que desasigna la memoria a la que apuntaba. Después de la eliminación, el puntero se convierte en un puntero colgante, ya que todavía mantiene la dirección de una memoria que ya no existe.

Acceder a un puntero colgante puede llevar a un comportamiento impredecible o incluso a fallos, ya que la memoria a la que apunta ya no es válida.

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 1. Capítulo 2