Si la asignación de memoria usando new falla en C++, ¿cómo se debe manejar?

En este artículo, si la asignación de memoria usando new falla en C++ , ¿cómo debería manejarse? Cuando un objeto de una clase se crea dinámicamente usando un operador nuevo , el objeto ocupa memoria en el montón. A continuación se presentan las cosas más importantes que se deben tener en cuenta:

• ¿Qué sucede si no hay suficiente memoria disponible en la memoria del montón y cómo debe manejarse?
• Si no se asigna memoria, ¿cómo evitar el bloqueo del proyecto?

A continuación se muestra el programa que ocupa una gran cantidad de memoria para que ocurra el problema. Utilice declaraciones de asignación de memoria en el bloque try and catch y para evitar el bloqueo de la memoria y lance la excepción cuando falle la asignación de memoria.

Programa 1:

// C++ program to illustrate memory
// failure when very large memory
// is allocated
#include <iostream>
using namespace std;
 
// Driver Code
int main()
{
    // Allocate huge amount of memory
    long MEMORY_SIZE = 0x7fffffff;
 
    // Put memory allocation statement
    // in the try catch block
    try {
        char* ptr = new char[MEMORY_SIZE];
 
        // When memory allocation fails,
        // below line is not be executed
        // & control will go in catch block
        cout << "Memory is allocated"
             << " Successfully" << endl;
    }
 
    // Catch Block handle error
    catch (const bad_alloc& e) {
 
        cout << "Memory Allocation"
             << " is failed: "
             << e.what()
             << endl;
    }
 
    return 0;
}

Memory Allocation is failed: std::bad_alloc

El problema de falla de memoria anterior se puede resolver sin usar el bloque try-catch . Se puede arreglar usando la versión nothrow del nuevo operador:

• El valor de la constante nothrow se usa como argumento para operator new y operator new[] para indicar que estas funciones no generarán una excepción en caso de falla, sino que devolverán un puntero nulo.
• De forma predeterminada, cuando se usa el operador new para intentar asignar memoria y la función de manejo no puede hacerlo, se lanza una excepción bad_alloc .
• Pero cuando nothrow se usa como argumento para new, y en su lugar devuelve un puntero nulo .
• Esta constante (nothrow) es solo un valor de tipo nothrow_t , con el único propósito de activar una versión sobrecargada de la función operator new (u operator new[]) que toma un argumento de este tipo.

A continuación se muestra la implementación de la asignación de memoria utilizando el operador nothrow :

Programa 2:

// C++ program to handle memory failure
// when very large memory is allocated
#include <iostream>
using namespace std;
 
// Drive Code
int main()
{
    // Allocate huge amount of memory
    long MEMORY_SIZE = 0x7fffffff;
 
    // Allocate memory dynamically
    // using "new" with "nothrow"
    // version of new
    char* addr = new (std::nothrow) char[MEMORY_SIZE];
 
    // Check if addr is having
    // proper address or not
    if (addr) {
 
        cout << "Memory is allocated"
             << " Successfully" << endl;
    }
    else {
 
        // This part will be executed if
        // large memory is allocated and
        // failure occurs
        cout << "Memory  allocation"
             << " fails" << endl;
    }
 
    return 0;
}

Memory  allocation fails