Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::bad_alloc — excepción por fallo de asignación

std::bad_alloc, de <new>, indica que no se ha podido asignar memoria. Aprende a capturarla por referencia constante, por qué what() no tiene un texto fijo portable y en qué se diferencia la asignación que lanza excepciones de std::nothrow.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#include <new>

try {
    // Operation that may fail to allocate storage.
} catch (const std::bad_alloc& e) {
    // Handle allocation failure.
}

// C++23 member signature:
// const char* what() const noexcept override;

std::bad_alloc, declarado en <new>, es una clase de excepción que deriva públicamente de std::exception. La implementación lo utiliza para indicar que no se ha podido asignar memoria. Tras un intento fallido, el operator new estándar que lanza excepciones llama al new_handler instalado; si no hay ninguno, lanza std::bad_alloc. Si el controlador retorna, se realiza otro intento.

Captura la excepción como const std::bad_alloc&. Su miembro what() devuelve una descripción terminada en nulo y definida por la implementación, así que no la compares con un texto fijo en las pruebas. Un controlador debería evitar asignaciones innecesarias: el siguiente intento también puede fallar.

La función de asignación estándar seleccionada por new (std::nothrow) T devuelve nullptr si falla, en lugar de indicar el fallo de asignación mediante una excepción. Esto no garantiza que la expresión completa no lance excepciones: el constructor de T todavía puede lanzar una.

El ejemplo ejecuta deliberadamente throw std::bad_alloc{} en vez de intentar agotar la memoria. Comprueba el manejo de excepciones, no un fallo real del asignador. Esta entrada se refiere a C++23; el borrador de trabajo actual puede incluir novedades posteriores, como constexpr para what(), que no deben darse por supuestas en C++23.

Ejemplos

#include <cstdio>
#include <new>

int main() {
    try {
        throw std::bad_alloc{};
    } catch (const std::bad_alloc&) {
        std::puts("Allocation failure caught");
    }
}

Resultado

Allocation failure caught

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes