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
Definiert im Header <new>
class bad_array_new_length : std:: bad_alloc
(seit C++11)

std::bad_array_new_length ist der Typ des Objekts, das als Exception von den new-expressions geworfen wird, um ungültige Array-Längen zu melden, wenn

  1. Array-Länge ist negativ,
  2. Die Gesamtgröße des neuen Arrays würde den implementierungsdefinierten Maximalwert überschreiten,
  3. Die Anzahl der Initialisierer überschreitet die Anzahl der zu initialisierenden Elemente.

Nur die erste Array-Dimension kann diese Ausnahme generieren; andere Dimensionen als die erste sind konstante Ausdrücke und werden zur Kompilierzeit überprüft.

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

Vererbungsdiagramm

Inhaltsverzeichnis

Memberfunktionen

(Konstruktor)
konstruiert ein neues bad_array_new_length Objekt
(öffentliche Elementfunktion)
operator=
ersetzt das bad_array_new_length Objekt
(öffentliche Elementfunktion)
what
gibt den erläuternden String zurück
(öffentliche Elementfunktion)

std::bad_array_new_length:: bad_array_new_length

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

Konstruiert ein neues bad_array_new_length -Objekt mit einer implementierungsdefinierten nullterminierten Byte-Zeichenkette, die über what() zugänglich ist.

1) Standardkonstruktor.
2) Kopierkonstruktor. Wenn * this und other beide den dynamischen Typ std::bad_array_new_length haben, dann gilt std:: strcmp ( what ( ) , other. what ( ) ) == 0 .

Parameter

other - ein weiteres Ausnahmeobjekt zum Kopieren

std::bad_array_new_length:: operator=

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

Weist die Inhalte mit denen von other zu. Wenn * this und other beide den dynamischen Typ std::bad_array_new_length haben, dann ist std:: strcmp ( what ( ) , other. what ( ) ) == 0 nach der Zuweisung.

Parameter

other - ein weiteres Ausnahmeobjekt, mit dem zugewiesen wird

Rückgabewert

* this

std::bad_array_new_length:: what

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

Gibt den erläuternden String zurück.

Rückgabewert

Zeiger auf einen implementierungsdefinierten nullterminierten String mit erläuternden Informationen. Der String ist geeignet für Konvertierung und Anzeige als std::wstring . Der Zeiger ist garantiert mindestens so lange gültig, bis das Ausnahmeobjekt, von dem er erhalten wurde, zerstört wird, oder bis eine nicht-konstante Memberfunktion (z.B. Kopierzuweisungsoperator) des Ausnahmeobjekts aufgerufen wird.

Der zurückgegebene String wird während der Konstantenauswertung mit der gewöhnlichen Literalkodierung kodiert.

(seit C++26)

Anmerkungen

Implementierungen dürfen, müssen aber nicht what() überschreiben.

Geerbt von std:: bad_alloc

Geerbt von std:: exception

Elementfunktionen

[virtual]
zerstört das Exception-Objekt
(virtuelle öffentliche Elementfunktion von std::exception )
[virtual]
gibt einen erklärenden String zurück
(virtuelle öffentliche Elementfunktion von std::exception )

Hinweise

Feature-Test Makro Wert Std Feature
__cpp_lib_constexpr_exceptions 202411L (C++26) constexpr für Ausnahmetypen

Beispiel

Drei Bedingungen, unter denen std::bad_array_new_length ausgelöst werden sollte:

Diesen Code ausführen 
#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";
}

Mögliche Ausgabe: 

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

Siehe auch

Allokierungsfunktionen
(Funktion)
Ausnahme, die bei fehlgeschlagener Speicherallokation geworfen wird
(Klasse)