Memoria dinámica C++

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

• La pila − Todas las variables declaradas dentro de la función ocuparán memoria de la pila.

• El montón − Esta es la memoria no utilizada del programa y se puede utilizar para asignar la memoria dinámicamente cuando se ejecuta el programa.

Muchas veces, no sabe de antemano cuánta memoria necesitará para almacenar información particular en una variable definida y el tamaño de la memoria requerida se puede determinar en tiempo de ejecución.

Puede asignar memoria en tiempo de ejecución dentro del montón para la variable de un tipo dado usando un operador especial en C++ que devuelve la dirección del espacio asignado. Este operador se llama nuevo operador.

Si ya no necesita memoria asignada dinámicamente, puede usar eliminar operador, que desasigna la memoria que fue previamente asignada por el nuevo operador.

operadores nuevos y eliminados

Hay la siguiente sintaxis genérica para usar nuevo operador para asignar memoria dinámicamente para cualquier tipo de datos.

new data-type;

Aquí, tipo de datos podría ser cualquier tipo de datos incorporado, incluida una matriz, o cualquier tipo de datos definido por el usuario que incluya clase o estructura. Comencemos con los tipos de datos integrados. Por ejemplo, podemos definir un puntero para escribir doble y luego solicitar que la memoria se asigne en el momento de la ejecución. Podemos hacer esto usando el nuevo operador con las siguientes declaraciones −

double* pvalue  = NULL; // Pointer initialized with null
pvalue  = new double;   // Request memory for the variable

Es posible que la memoria no se haya asignado correctamente si se agotó el almacenamiento libre. Por lo tanto, es una buena práctica verificar si el nuevo operador devuelve un puntero NULL y tomar las medidas apropiadas como se muestra a continuación:

double* pvalue  = NULL;
if( !(pvalue  = new double )) {
   cout << "Error: out of memory." <<endl;
   exit(1);
}

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

En cualquier momento, cuando sienta que una variable que ha sido asignada dinámicamente ya no es necesaria, puede liberar la memoria que ocupa en la tienda libre con el operador 'eliminar' de la siguiente manera −

delete pvalue;        // Release memory pointed to by pvalue

Pongamos los conceptos anteriores y formemos el siguiente ejemplo para mostrar cómo funcionan 'nuevo' y 'eliminar' −

Demostración en vivo

#include <iostream>
using namespace std;

int main () {
   double* pvalue  = NULL; // Pointer initialized with null
   pvalue  = new double;   // Request memory for the variable
 
   *pvalue = 29494.99;     // Store value at allocated address
   cout << "Value of pvalue : " << *pvalue << endl;

   delete pvalue;         // free up the memory.

   return 0;
}

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

Value of pvalue : 29495

Asignación dinámica de memoria para arreglos

Considere que desea asignar memoria para una matriz de caracteres, es decir, una cadena de 20 caracteres. Usando la misma sintaxis que hemos usado anteriormente, podemos asignar memoria dinámicamente como se muestra a continuación.

char* pvalue  = NULL;         // Pointer initialized with null
pvalue  = new char[20];       // Request memory for the variable

Para eliminar la matriz que acabamos de crear, la declaración se vería así −

delete [] pvalue;             // Delete array pointed to by pvalue

Siguiendo la sintaxis genérica similar del operador nuevo, puede asignar una matriz multidimensional de la siguiente manera −

double** pvalue  = NULL;      // Pointer initialized with null 
pvalue  = new double [3][4];  // Allocate memory for a 3x4 array 

Sin embargo, la sintaxis para liberar la memoria para una matriz multidimensional seguirá siendo la misma que la anterior −

delete [] pvalue;            // Delete array pointed to by pvalue

Asignación dinámica de memoria para objetos

Los objetos no son diferentes de los tipos de datos simples. Por ejemplo, considere el siguiente código donde vamos a usar una matriz de objetos para aclarar el concepto:

Demostración en vivo

#include <iostream>
using namespace std;

class Box {
   public:
      Box() { 
         cout << "Constructor called!" <<endl; 
      }
      ~Box() { 
         cout << "Destructor called!" <<endl; 
      }
};
int main() {
   Box* myBoxArray = new Box[4];
   delete [] myBoxArray; // Delete array

   return 0;
}

Si tuviera que asignar una matriz de cuatro objetos Box, el constructor Simple se llamaría cuatro veces y, de manera similar, al eliminar estos objetos, el destructor también se llamaría la misma cantidad de veces.

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

Constructor called!
Constructor called!
Constructor called!
Constructor called!
Destructor called!
Destructor called!
Destructor called!
Destructor called!