Namespaces
Variants

std:: bad_array_new_length

From cppreference.net
< cpp ‎ | memory ‎ | new
C++
Utilities library
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
Low level memory management
Definido en el encabezado <new>
class bad_array_new_length : std:: bad_alloc
(desde C++11)

std::bad_array_new_length es el tipo del objeto lanzado como excepción por las expresiones new para reportar longitudes de array inválidas si

  1. La longitud del array es negativa,
  2. El tamaño total del nuevo array excedería el valor máximo definido por la implementación,
  3. El número de cláusulas de inicialización excede el número de elementos a inicializar.

Solo la primera dimensión del array puede generar esta excepción; las dimensiones distintas de la primera son expresiones constantes y se verifican en tiempo de compilación.

cpp/error/exception cpp/memory/new/bad alloc std-bad array new length-inheritance.svg

Diagrama de herencia

Contenidos

Funciones miembro

(constructor)
construye un nuevo objeto bad_array_new_length
(función miembro pública)
operator=
reemplaza el objeto bad_array_new_length
(función miembro pública)
what
devuelve la cadena explicativa
(función miembro pública)

std::bad_array_new_length:: bad_array_new_length

bad_array_new_length ( ) noexcept ;
(1) (desde C++11)
(constexpr desde C++26)
bad_array_new_length ( const bad_array_new_length & other ) noexcept ;
(2) (desde C++11)
(constexpr desde C++26)

Construye un nuevo objeto bad_array_new_length con una cadena de bytes terminada en nulo definida por la implementación que es accesible a través de what() .

1) Constructor por defecto.
2) Constructor de copia. Si * this y other tienen ambos el tipo dinámico std::bad_array_new_length entonces std:: strcmp ( what ( ) , other. what ( ) ) == 0 .

Parámetros

other - otro objeto de excepción a copiar

std::bad_array_new_length:: operator=

bad_array_new_length & operator = ( const bad_array_new_length & other ) noexcept ;
(desde C++11)
(constexpr desde C++26)

Asigna los contenidos con los de other . Si * this y other ambos tienen tipo dinámico std::bad_array_new_length entonces std:: strcmp ( what ( ) , other. what ( ) ) == 0 después de la asignación.

Parámetros

other - otro objeto de excepción con el cual asignar

Valor de retorno

* this

std::bad_array_new_length:: what

virtual const char * what ( ) const noexcept ;
(desde C++11)
(constexpr desde C++26)

Devuelve la cadena explicativa.

Valor de retorno

Puntero a una cadena terminada en nulo definida por la implementación con información explicativa. La cadena es adecuada para conversión y visualización como std::wstring . Se garantiza que el puntero es válido al menos hasta que se destruye el objeto de excepción del cual se obtiene, o hasta que se llama a una función miembro no constante (por ejemplo, el operador de asignación de copia) en el objeto de excepción.

La cadena devuelta está codificada con la codificación literal ordinaria durante la evaluación constante.

(desde C++26)

Notas

Las implementaciones pueden, pero no están obligadas a, sobrescribir what() .

Heredado de std:: bad_alloc

Heredado de std:: exception

Funciones miembro

[virtual]
destruye el objeto de excepción
(función miembro pública virtual de std::exception )
[virtual]
devuelve una cadena explicativa
(función miembro pública virtual de std::exception )

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_constexpr_exceptions 202411L (C++26) constexpr para tipos de excepción

Ejemplo

Tres condiciones donde std::bad_array_new_length debería lanzarse:

Ejecutar este código 
#include <climits>
#include <iostream>
#include <new>
int main()
{
    try
    {
        int negative = -1;
        new int[negative];
    }
    catch (const std::bad_array_new_length& e)
    {
        std::cout << "1) " << e.what() << ": negative size\n";
    }
    try
    {
        int small = 1;
        new int[small]{1,2,3};
    }
    catch (const std::bad_array_new_length& e)
    {
        std::cout << "2) " << e.what() << ": too many initializers\n";
    }
    try
    {
        long large = LONG_MAX;
        new int[large][1000];
    } 
    catch (const std::bad_array_new_length& e)
    {
        std::cout << "3) " << e.what() << ": too large\n";
    }
    std::cout << "End\n";
}

Salida posible: 

1) std::bad_array_new_length: negative size
2) std::bad_array_new_length: too many initializers
3) std::bad_array_new_length: too large
End

Véase también

funciones de asignación
(función)
excepción lanzada cuando falla la asignación de memoria
(clase)