C++ Memoria dinámica

Entender cómo funciona la memoria dinámica en C++ es esencial para convertirte en un programador de C++ competente. La memoria en un programa de C++ se divide en dos partes:

  • Pila (stack):Todas las variables declaradas dentro de una función ocuparán memoria de la pila.
  • Montón (heap):Esta es la memoria no utilizada del programa, que se puede usar para asignar memoria dinámicamente durante la ejecución del programa.

Muchas veces no puedes predecir de antemano cuánta memoria necesitas para almacenar información específica en una variable definida; el tamaño de memoria requerido solo puede determinarse en tiempo de ejecución.

En C++, puedes usar operadores especiales para asignar memoria en el montón en tiempo de ejecución para variables de un tipo dado, lo que devuelve la dirección del espacio asignado. Este tipo de operador esnewoperador.

Si ya no necesitas el espacio de memoria asignado dinámicamente, puedes usardeleteoperador para liberar la memoria asignada previamente por el operador new.

Los operadores new y delete

A continuación se muestra la sintaxis general para usar el operador new a fin de asignar memoria dinámicamente para cualquier tipo de datos:

new data-type;

Aquí,data-typepuede ser cualquier tipo de datos integrado, incluidos los arreglos, o cualquier tipo de datos definido por el usuario, incluidas clases o estructuras. Veamos primero los tipos de datos integrados. Por ejemplo, podemos definir un puntero al tipo double y luego solicitar memoria, la cual se asigna en tiempo de ejecución. Podemos usar la siguiente declaración connewoperador para lograr esto:

double* pvalue = NULL; // puntero inicializado a null pvalue = new double; // solicitar memoria para la variable

Si el área de almacenamiento libre se ha agotado, es posible que la asignación de memoria no se realice correctamente. Por lo tanto, se recomienda verificar si el operador new devuelve un puntero NULL y tomar las medidas adecuadas:

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

malloc()La función ya apareció en el lenguaje C y todavía existe en C++, pero se recomienda evitar el uso de la función malloc() en la medida de lo posible. En comparación con malloc(), la principal ventaja de new es que new no solo asigna memoria, sino que también crea objetos.

En cualquier momento, cuando consideres que una variable con memoria asignada dinámicamente ya no es necesaria, puedes usar el operador delete para liberar la memoria que ocupa, como se muestra a continuación:

delete pvalue;        // 释放 pvalue 所指向的内存

El siguiente ejemplo utiliza los conceptos anteriores y demuestra cómo usar los operadores new y delete:

Ejemplo

#include <iostream> using namespace std; int main () { double* pvalue = NULL; // puntero inicializado a null pvalue = new double; // solicitar memoria para la variable *pvalue = 29494.99; // almacenar el valor en la dirección asignada cout << "Value of pvalue : " << *pvalue << endl; delete pvalue; // liberar memoria return 0; }

Cuando el código anterior se compila y se ejecuta, produce los siguientes resultados:

Value of pvalue : 29495

Asignación dinámica de memoria para arreglos

Supongamos que queremos asignar memoria para un arreglo de caracteres (una cadena de 20 caracteres). Podemos usar la sintaxis del ejemplo anterior para asignar memoria dinámicamente al arreglo, de la siguiente manera:

char* pvalue  = NULL;   // 初始化为 null 的指针
pvalue  = new char[20]; // 为变量请求内存

Para eliminar el arreglo que acabamos de crear, la declaración es la siguiente:

delete [] pvalue;        // 删除 pvalue 所指向的数组

A continuación se muestra la sintaxis general del operador new para asignar memoria a arreglos multidimensionales:

Arreglo unidimensional

// asignación dinámica, longitud del arreglo m int *array=new int [m]; // liberar memoria delete [] array;

Arreglo bidimensional

int **array; // supongamos que la primera dimensión del arreglo tiene longitud m y la segunda dimensión tiene longitud n // asignar espacio dinámicamente array = new int *[m]; for( int i=0; i<m; i++ ) { array[i] = new int [n]; } // liberar for( int i=0; i<m; i++ ) { delete [] array[i]; } delete [] array;

Prueba de ejemplo de arreglo bidimensional:

Ejemplo

#include <iostream> using namespace std; int main() { int **p; int i,j; //p[4][8] // comenzar a asignar datos bidimensionales de 4 filas y 8 columnas p = new int *[4]; for(i=0;i<4;i++){ p[i]=new int [8]; } for(i=0; i<4; i++){ for(j=0; j<8; j++){ p[i][j] = j*i; } } // imprimir datos for(i=0; i<4; i++){ for(j=0; j<8; j++) { if(j==0) cout<<endl; cout<<p[i][j]<<"\t"; } } // comenzar a liberar el montón solicitado for(i=0; i<4; i++){ delete [] p[i]; } delete [] p; return 0; }

Arreglo tridimensional

int ***array; // supongamos que la primera dimensión del arreglo es m, la segunda es n y la tercera es h // asignar espacio dinámicamente array = new int **[m]; for( int i=0; i<m; i++ ) { array[i] = new int *[n]; for( int j=0; j<n; j++ ) { array[i][j] = new int [h]; } } // liberar for( int i=0; i<m; i++ ) { for( int j=0; j<n; j++ ) { delete[] array[i][j]; } delete[] array[i]; } delete[] array;

Ejemplo de prueba de arreglo tridimensional:

Ejemplo

#include <iostream> using namespace std; int main() { int i,j,k; // p[2][3][4] int ***p; p = new int **[2]; for(i=0; i<2; i++) { p[i]=new int *[3]; for(j=0; j<3; j++) p[i][j]=new int[4]; } // generar los datos tridimensionales p[i][j][k] for(i=0; i<2; i++) { for(j=0; j<3; j++) { for(k=0;k<4;k++) { p[i][j][k]=i+j+k; cout<<p[i][j][k]<<" "; } cout<<endl; } cout<<endl; } // liberar memoria for(i=0; i<2; i++) { for(j=0; j<3; j++) { delete [] p[i][j]; } } for(i=0; i<2; i++) { delete [] p[i]; } delete [] p; return 0; }

Asignación dinámica de memoria para objetos

Los objetos no son diferentes de los tipos de datos simples. Por ejemplo, mira el siguiente código; usaremos un arreglo de objetos para aclarar este concepto:

Ejemplo

#include <iostream> using namespace std; class Box { public: Box() { cout << "¡Llamando al constructor!" <<endl; } ~Box() { cout << "¡Llamando al destructor!" <<endl; } }; int main( ) { Box* myBoxArray = new Box[4]; delete [] myBoxArray; // eliminar el arreglo return 0; }

Si deseas asignar memoria para un arreglo que contiene cuatro objetos Box, el constructor se llamará 4 veces; de manera similar, al eliminar estos objetos, el destructor también se llamará la misma cantidad de veces (4 veces).

Cuando el código anterior se compila y se ejecuta, produce los siguientes resultados:

¡Llamando al constructor!
¡Llamando al constructor!
¡Llamando al constructor!
¡Llamando al constructor!
¡Llamando al destructor!
¡Llamando al destructor!
¡Llamando al destructor!
¡Llamando al destructor!
Otras extensiones