La asignación de memoria dinámica en C/C++ se refiere a la asignación de memoria manual por parte de un programador. La memoria asignada dinámicamente se asigna en Montón, y las variables locales y no estáticas obtienen memoria asignada Pila (Referirse a Programas de diseño de memoria C para detalles).

¿Qué son las aplicaciones?

• Un uso de la memoria asignada dinámicamente es asignar memoria de tamaño variable, lo cual no es posible con la memoria asignada por el compilador, excepto para matrices de longitud variable .
• El uso más importante es la flexibilidad proporcionada a los programadores. Somos libres de asignar y desasignar memoria cuando la necesitemos y cuando ya no la necesitemos. Hay muchos casos en los que esta flexibilidad ayuda. Ejemplos de tales casos son Árbol , etc.

¿En qué se diferencia de la memoria asignada a variables normales?

Para variables normales como int a, char str[10], etc., la memoria se asigna y desasigna automáticamente. Para memoria asignada dinámicamente como int *p = new int[10], es responsabilidad del programador desasignar memoria cuando ya no sea necesaria. Si el programador no desasigna la memoria, provoca un pérdida de memoria (La memoria no se desasigna hasta que finaliza el programa).

¿Cómo se asigna/desasigna la memoria en C++?
C usa el malloc() y calloc() función para asignar memoria dinámicamente en tiempo de ejecución y utiliza una función free() para liberar memoria asignada dinámicamente. C++ soporta estas funciones y también tiene dos operadores nuevo y borrar, que realizan la tarea de asignar y liberar la memoria de una forma mejor y más sencilla.

nuevo operador

El nuevo operador indica una solicitud de asignación de memoria en la Tienda gratuita. Si hay suficiente memoria disponible, un nuevo operador inicializa la memoria y devuelve la dirección de la memoria recién asignada e inicializada a la variable de puntero.

Sintaxis para usar nuevo operador

prueba el bloque catch en java

pointer-variable =   new   data-type;>

Aquí, la variable de puntero es el puntero de tipo tipo de datos. El tipo de datos puede ser cualquier tipo de datos integrado, incluida una matriz, o cualquier tipo de datos definido por el usuario, incluida la estructura y la clase.
Ejemplo:

// Pointer initialized with NULL // Then request memory for the variable int *p = NULL;  p = new int;    OR  // Combine declaration of pointer  // and their assignment int *p = new int;>

// C++ program to demonstrate how to create dynamic variable // using new #include  #include  using namespace std; int main() {  // pointer to store the address returned by the new  int* ptr;  // allocating memory for integer  ptr = new int;  // assigning value using dereference operator  *ptr = 10;  // printing value and address  cout << 'Address: ' << ptr << endl;  cout << 'Value: ' << *ptr;  return 0; }>

Address: 0x162bc20 Value: 10>

Inicializar memoria: También podemos inicializar la memoria para tipos de datos integrados usando un nuevo operador. Para tipos de datos personalizados, se requiere un constructor (con el tipo de datos como entrada) para inicializar el valor. A continuación se muestra un ejemplo de la inicialización de ambos tipos de datos:

pointer-variable =   new   data-type(value);>

Ejemplo:

// C++ program to illustrate how to initialize a dynamic // variable with allocation #include  #include  using namespace std; // Custom data type with constructor to take initial value struct cust {  int p;  cust(int q)  : p(q)  {  }  cust() = default; }; int main() {  // creating inbuit data types with initial value  int* p = new int(25);  float* q = new float(75.25);  // Works fine, doesn’t require constructor  cust* var1 = new cust;  // OR  // Works fine, doesn’t require constructor  var1 = new cust();  // Notice error if you comment this line  cust* var = new cust(25);  cout << *p << ' ' << *q << ' ' << var->pag;  devolver 0; }>

25 75.25 25>

Asigne un bloque de memoria: También se utiliza un nuevo operador para asignar un bloque (una matriz) de memoria de tipo tipo de datos .

pointer-variable =   new   data-type[size];>

donde tamaño (una variable) especifica la cantidad de elementos en una matriz.

Ejemplo:

¿Cómo funciona una computadora?

int *p = new int[10]>

Asigna dinámicamente memoria para 10 números enteros continuamente de tipo int y devuelve un puntero al primer elemento de la secuencia, al que se le asigna top (un puntero). p[0] se refiere al primer elemento, p[1] se refiere al segundo elemento, y así sucesivamente.

Declaración de matriz normal versus uso de nuevo
Existe una diferencia entre declarar una matriz normal y asignar un bloque de memoria usando new. La diferencia más importante es que el compilador desasigna las matrices normales (si la matriz es local, se desasigna cuando la función regresa o se completa). Sin embargo, las matrices asignadas dinámicamente siempre permanecen allí hasta que el programador las desasigna o el programa finaliza.

¿Qué pasa si no hay suficiente memoria disponible durante el tiempo de ejecución?
Si no hay suficiente memoria disponible en el montón para asignar, la nueva solicitud indica un error al generar una excepción de tipo std::bad_alloc, a menos que se use nothrow con el nuevo operador, en cuyo caso devuelve un puntero NULL (desplácese a la sección Excepción manejo de nuevo operador en este artículo). Por lo tanto, puede ser una buena idea verificar la variable de puntero producida por new antes de usar su programa.

int *p = new(nothrow) int; if (!p) {  cout << 'Memory allocation failed
'; }>

eliminar operador

Dado que es responsabilidad del programador desasignar la memoria asignada dinámicamente, los programadores reciben un operador de eliminación en lenguaje C++.

Sintaxis:

// Release memory pointed by pointer-variable   delete   pointer-variable;>

Aquí, la variable de puntero es el puntero que apunta al objeto de datos creado por nuevo .

Ejemplos:

delete p; delete q;>

Para liberar la matriz asignada dinámicamente apuntada por la variable de puntero, utilice la siguiente forma de borrar :

cadenas de clasificación java

  // Release block of memory     // pointed by pointer-variable  delete[] pointer-variable;     Example:    // It will free the entire array    // pointed by p.   delete[] p;>

// C++ program to illustrate dynamic allocation // and deallocation of memory using new and delete #include  using namespace std; int main() {  // Pointer initialization to null  int* p = NULL;  // Request memory for the variable  // using new operator  p = new (nothrow) int;  if (!p)  cout << 'allocation of memory failed
';  else {  // Store value at allocated address  *p = 29;  cout << 'Value of p: ' << *p << endl;  }  // Request block of memory  // using new operator  float* r = new float(75.25);  cout << 'Value of r: ' << *r << endl;  // Request block of memory of size n  int n = 5;  int* q = new (nothrow) int[n];  if (!q)  cout << 'allocation of memory failed
';  else {  for (int i = 0; i < n; i++)  q[i] = i + 1;  cout << 'Value store in block of memory: ';  for (int i = 0; i < n; i++)  cout << q[i] << ' ';  }  // freed the allocated memory  delete p;  delete r;  // freed the block of allocated memory  delete[] q;  return 0; }>

Value of p: 29 Value of r: 75.25 Value store in block of memory: 1 2 3 4 5>

Complejidad del tiempo: O(n), donde n es el tamaño de memoria dado.

Artículos relacionados:

• Prueba sobre nuevos y eliminar
• eliminar vs gratis