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
Défini dans l'en-tête <new>
class bad_array_new_length : std:: bad_alloc
(depuis C++11)

std::bad_array_new_length est le type de l'objet levé comme exception par les new-expressions pour signaler des longueurs de tableau invalides si

  1. La longueur du tableau est négative,
  2. La taille totale du nouveau tableau dépasserait la valeur maximale définie par l'implémentation,
  3. Le nombre de clauses d'initialisation dépasse le nombre d'éléments à initialiser.

Seule la première dimension du tableau peut générer cette exceptions ; les dimensions autres que la première sont des expressions constantes et sont vérifiées au moment de la compilation.

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

Diagramme d'héritage

Table des matières

Fonctions membres

(constructeur)
construit un nouvel objet bad_array_new_length
(fonction membre publique)
operator=
remplace l'objet bad_array_new_length
(fonction membre publique)
what
retourne la chaîne explicative
(fonction membre publique)

std::bad_array_new_length:: bad_array_new_length

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

Construit un nouvel objet bad_array_new_length avec une chaîne d'octets terminée par un caractère nul définie par l'implémentation, accessible via what() .

1) Constructeur par défaut.
2) Constructeur de copie. Si * this et other ont tous deux le type dynamique std::bad_array_new_length alors std:: strcmp ( what ( ) , other. what ( ) ) == 0 .

Paramètres

other - un autre objet d'exception à copier

std::bad_array_new_length:: operator=

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

Assigne le contenu avec celui de other . Si * this et other ont tous deux le type dynamique std::bad_array_new_length alors std:: strcmp ( what ( ) , other. what ( ) ) == 0 après l'assignation.

Paramètres

other - autre objet d'exception à assigner

Valeur de retour

* this

std::bad_array_new_length:: what

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

Retourne la chaîne explicative.

Valeur de retour

Pointeur vers une chaîne implémentation-définie terminée par un caractère nul contenant des informations explicatives. La chaîne est adaptée à la conversion et à l'affichage en tant que std::wstring . Le pointeur est garanti valide au moins jusqu'à la destruction de l'objet exception duquel il est obtenu, ou jusqu'à l'appel d'une fonction membre non-const (par exemple l'opérateur d'affectation par copie) sur l'objet exception.

La chaîne retournée est encodée avec l'encodage littéral ordinaire pendant l'évaluation constante.

(depuis C++26)

Notes

Les implémentations sont autorisées mais non requises à redéfinir what() .

Hérité de std:: bad_alloc

Hérité de std:: exception

Fonctions membres

[virtuel]
détruit l'objet exception
(fonction membre publique virtuelle de std::exception )
[virtuel]
retourne une chaîne explicative
(fonction membre publique virtuelle de std::exception )

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_constexpr_exceptions 202411L (C++26) constexpr pour les types d'exception

Exemple

Trois situations où std::bad_array_new_length devrait être levée :

Exécuter ce code 
#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";
}

Sortie possible : 

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

Voir aussi

fonctions d'allocation
(fonction)
exception levée lorsque l'allocation de mémoire échoue
(classe)