Dominando la Memoria Dinámica en C++: Stack vs Heap Explicado

Una buena comprensión de cómo la memoria dinámica realmente funciona en C++ es esencial para convertirse en un buen programador de C++. La memoria en tu programa C++ se divide en dos partes:

• La pila (stack): Todas las variables declaradas dentro de la función tomarán memoria de la pila.

• El montículo (heap): Esta es memoria no usada del programa y puede usarse para asignar memoria dinámicamente cuando el programa se ejecuta.

Muchas veces, no sabes de antemano cuánta memoria necesitarás para almacenar información particular en una variable definida y el tamaño de memoria requerido puede determinarse en tiempo de ejecución.

Puedes asignar memoria en tiempo de ejecución dentro del montículo para la variable de un tipo dado usando un operador especial en C++ que retorna la dirección del espacio asignado. Este operador se llama operador new.

Si ya no necesitas memoria asignada dinámicamente, puedes usar el operador delete, que desasigna memoria que fue previamente asignada por el operador new.

Operadores new y delete

Hay la siguiente sintaxis genérica para usar el operador new para asignar memoria dinámicamente para cualquier tipo de dato.

new tipo-dato;

Aquí, tipo-dato podría ser cualquier tipo de dato integrado incluyendo un array o cualquier tipo de dato definido por el usuario que incluya clase o estructura. Empecemos con tipos de datos integrados. Por ejemplo, podemos definir un puntero a tipo double y luego solicitar que la memoria sea asignada en tiempo de ejecución. Podemos hacer esto usando el operador new con las siguientes declaraciones:

double* pvalor = NULL; // Puntero inicializado con null
pvalor = new double;   // Solicitar memoria para la variable

La memoria puede no haber sido asignada exitosamente, si el almacenamiento libre se ha agotado. Así que es buena práctica verificar si el operador new está retornando un puntero NULL y tomar la acción apropiada como se muestra a continuación:

double* pvalor = NULL;
if(!(pvalor = new double)) {
    cout << "Error: sin memoria." << endl;
    exit(1);
}

La función malloc() de C, todavía existe en C++, pero se recomienda evitar usar la función malloc(). La principal ventaja de new sobre malloc() es que new no solo asigna memoria, construye objetos que es el propósito principal de C++.

En cualquier momento, cuando sientas que una variable que ha sido asignada dinámicamente ya no es requerida, puedes liberar la memoria que ocupa en el almacenamiento libre con el operador 'delete' de la siguiente manera:

delete pvalor; // Liberar memoria apuntada por pvalor

Pongamos los conceptos anteriores y formemos el siguiente ejemplo para mostrar cómo funcionan 'new' y 'delete':

#include <iostream>
using namespace std;
int main() {
    double* pvalor = NULL; // Puntero inicializado con null
    pvalor = new double;   // Solicitar memoria para la variable
    *pvalor = 29494.99;    // Almacenar valor en dirección asignada
    cout << "Valor de pvalor: " << *pvalor << endl;
    delete pvalor;         // liberar la memoria.
    return 0;
}

Si compilamos y ejecutamos el código anterior, esto produciría el siguiente resultado:

Valor de pvalor: 29495

Asignación Dinámica de Memoria para Arrays

Considera que quieres asignar memoria para un array de caracteres, es decir, una cadena de 20 caracteres. Usando la misma sintaxis que hemos usado arriba, podemos asignar memoria dinámicamente como se muestra a continuación.

char* pvalor = NULL;      // Puntero inicializado con null
pvalor = new char[20];    // Solicitar memoria para la variable

Para eliminar el array que acabamos de crear, la declaración se vería así:

delete[] pvalor; // Eliminar array apuntado por pvalor

Siguiendo la sintaxis genérica similar del operador new, puedes asignar para un array multidimensional de la siguiente manera:

double** pvalor = NULL;         // Puntero inicializado con null
pvalor = new double[3][4];      // Asignar memoria para un array 3x4

Sin embargo, la sintaxis para liberar la memoria para array multidimensional seguirá siendo la misma que arriba:

delete[] pvalor; // Eliminar array apuntado por pvalor

Asignación Dinámica de Memoria para Objetos

Los objetos no son diferentes de los tipos de datos simples. Por ejemplo, considera el siguiente código donde vamos a usar un array de objetos para clarificar el concepto:

#include <iostream>
using namespace std;
class Caja {
public:
    Caja() {
        cout << "Constructor llamado!" << endl;
    }
    ~Caja() {
        cout << "Destructor llamado!" << endl;
    }
};
int main() {
    Caja* miArrayCajas = new Caja[4];
    delete[] miArrayCajas; // Eliminar array
    return 0;
}

Si asignaras un array de cuatro objetos Caja, el constructor simple sería llamado cuatro veces y similarmente al eliminar estos objetos, el destructor también será llamado el mismo número de veces.

Si compilamos y ejecutamos el código anterior, esto produciría el siguiente resultado:

Constructor llamado!
Constructor llamado!
Constructor llamado!
Constructor llamado!
Destructor llamado!
Destructor llamado!
Destructor llamado!
Destructor llamado!