Latest web development tutorials

memoria dinámica C ++

Entender la dinámica de memoria en C ++ es cómo el trabajo es convertirse en un cualificado C ++ programadores esenciales. memoria de programa C ++ se divide en dos partes:

  • Stack: todas las variables declaradas dentro de una función se ocupará de la memoria de pila.
  • Montón: Esta es lamemoria de programa no se utiliza, se ejecuta el programa se puede utilizar para asignar dinámicamente la memoria.

Muchas veces, no se puede predecir de antemano cómo se requiere mucha memoria para almacenar una variable definida en la información específica necesaria para determinar el tamaño de memoria necesaria en tiempo de ejecución.

En C ++, se puede utilizar un operador especial se asigna a una variable de un tipo dado de memoria dentro de la pila en tiempo de ejecución, devuelve el espacio de direcciones asignado. Este operador es sernuevo operador.

Si no necesita asignar dinámicamente la memoria, puede utilizar el operadordelete, eliminado por el nuevo operador antes de que la memoria asignada.

operadores new y delete

Aquí está el nuevo operador para ser cualquier sintaxis general de la asignación dinámica de tipo de datos de la memoria: 

new data-type;

Aquí, de tipo de datos puede ser cualquier incorporados en los tipos de datos, incluyendo matrices, puede ser cualquier tipo de datos que incluye una clase o estructura, incluyendo definida por el usuario.Veamos primero a los tipos de datos incorporados. Por ejemplo, podemos definir un puntero a un puntero de tipo double, a continuación, las peticiones de memoria, la memoria se asigna en tiempo de ejecución. Podemos utilizar elnuevo operador de acuerdo con la siguiente afirmación de lograr esto:

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

Si las áreas de almacenamiento libres se han agotado, no puede asignar correctamente memoria. Es recomendable comprobar si el nuevo operador devuelve un puntero NULL, y tomar la acción apropiada la siguiente: 

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

}

la funciónmalloc () en el lenguaje C ++ apareció en C está todavía presente, pero se recomienda no utilizar malloc (función).función nueva y malloc () en comparación con su principal ventaja es que, no sólo asignar nueva memoria, sino que también crea el objeto.

En cualquier momento, cuando sientes que una dinámica de las variables de memoria ya asignada ya no es necesario, puede utilizar el operador delete para liberar la memoria que ocupaba, de la siguiente manera: 

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

Se utiliza en el concepto anterior, el siguiente ejemplo muestra cómo utilizar el nuevo y borrar los operadores: 

#include <iostream>
using namespace std;

int main ()
{
   double* pvalue  = NULL; // 初始化为 null 的指针
   pvalue  = new double;   // 为变量请求内存
 
   *pvalue = 29494.99;     // 在分配的地址存储值
   cout << "Value of pvalue : " << *pvalue << endl;

   delete pvalue;         // 释放内存

   return 0;
}

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

Value of pvalue : 29495

Una matriz de asignación de memoria dinámica

Supongamos que queremos una matriz de caracteres (una cadena de 20 caracteres) para asignar memoria, podemos usar el ejemplo anterior de la sintaxis de matrices para asignar dinámicamente la memoria, de la siguiente manera: 

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

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

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

Aquí es la sintaxis general nuevo operador puede asignar memoria para las matrices multidimensionales, de la siguiente manera: 

int ROW = 2;
int COL = 3;
double **pvalue  = new double* [ROW]; // 为行分配内存

// 为列分配内存
for(int i = 0; i < COL; i++) {
    pvalue[i] = new double[COL];
}

Liberar la memoria matriz multidimensional: 

for(int i = 0; i < COL; i++) {
    delete[] pvalue[i];
}
delete [] pvalue;

La memoria dinámica objeto de asignación

El objeto no es diferente de los tipos de datos simples. Por ejemplo, considere el siguiente código, vamos a utilizar una gran variedad de objetos para aclarar este concepto: 

#include <iostream>
using namespace std;

class Box
{
   public:
      Box() { 
         cout << "调用构造函数！" <<endl; 
      }
      ~Box() { 
         cout << "调用析构函数！" <<endl; 
      }
};

int main( )
{
   Box* myBoxArray = new Box[4];

   delete [] myBoxArray; // Delete array

   return 0;
}

Si quieres una caja contiene cuatro objetos asignan matriz de memoria, el constructor será llamado cuatro veces, de la misma manera, al eliminar estos objetos, el destructor será llamado el mismo número de veces (cuatro veces).

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

调用构造函数！
调用构造函数！
调用构造函数！
调用构造函数！
调用析构函数！
调用析构函数！
调用析构函数！
调用析构函数！