std::overflow_error

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Diagnostik-Bibliothek

Ausnahmebehandlung exception uncaught_exceptionuncaught_exceptions (bis C++20*)  (C++17) exception_ptr (C++11) make_exception_ptr (C++11) current_exception (C++11) rethrow_exception (C++11) nested_exception (C++11) throw_with_nested (C++11) rethrow_if_nested (C++11) Exception handling failures terminate terminate_handler get_terminate (C++11) set_terminate bad_exception unexpected (bis C++17*) unexpected_handler (bis C++17*) get_unexpected (bis C++17*) set_unexpected (bis C++17*) Fehlernummern Error codes errno Assertions assert

Exception categories logic_error invalid_argument domain_error length_error out_of_range runtime_error range_error overflow_error underflow_error tx_exception (TM TS) System error error_category (C++11) generic_category (C++11) system_category (C++11) error_condition (C++11) errc (C++11) error_code (C++11) system_error (C++11) Stacktrace stacktrace_entry (C++23) basic_stacktrace (C++23) Debugging-Unterstützung is_debugger_present (C++26) breakpoint_if_debugging (C++26) breakpoint (C++26)

 

Definiert in der Header-Datei <stdexcept>
class overflow_error;

Definiert einen Objekttyp, der als Ausnahme geworfen werden kann. Er kann zur Meldung von arithmetischen Überlauffehlern verwendet werden (d. h. Situationen, in denen das Ergebnis einer Berechnung zu groß für den Zieltyp ist).

Die einzige Standardbibliothekskomponente, die diese Ausnahme auslöst, ist std::bitset::to_ulong.	(bis C++11)
Die einzigen Standardbibliothekskomponenten, die diese Ausnahme auslösen, sind std::bitset::to_ulong und std::bitset::to_ullong.	(seit C++11)

Die mathematischen Funktionen der Standardbibliothekskomponenten lösen diese Ausnahme nicht aus (mathematische Funktionen melden Überlauffehler gemäß math_errhandling). Drittanbieterbibliotheken verwenden sie jedoch. Zum Beispiel wirft boost.math std::overflow_error, wenn boost::math::policies::throw_on_error aktiviert ist (Standardeinstellung).

Vererbungdiagramm

Memberfunktionen

(Konstruktor)	konstruiert ein neues overflow_error-Objekt mit der angegebenen Nachricht (öffentliche Memberfunktion)
operator=	weist dem overflow_error-Objekt neue Inhalte zu (öffentliche Memberfunktion)

std::overflow_error::overflow_error

overflow_error( const std::string& what_arg );	(1)
overflow_error( const char* what_arg );	(2)
overflow_error( const overflow_error& other );	(3)	(noexcept seit C++11)

1) Konstruiert das Ausnahmeobjekt mit what_arg als erklärende Zeichenkette. Nach der Konstruktion gilt std::strcmp(what(), what_arg.c_str()) == 0.

2) Konstruiert das Ausnahmeobjekt mit what_arg als erklärende Zeichenkette. Nach der Konstruktion gilt std::strcmp(what(), what_arg) == 0.

3) Kopierkonstruktor. Wenn *this und other beide den dynamischen Typ std::overflow_error haben, dann ist std::strcmp(what(), other.what()) == 0. Aus dem Kopierkonstruktor kann keine Ausnahme geworfen werden.

Parameter

what_arg	-	erklärende Zeichenkette
Sonstiges	-	ein anderes Ausnahmeobjekt zum Kopieren

Ausnahmen

1,2) Kann std::bad_alloc auslösen.

Anmerkungen

Da das Kopieren von std::overflow_error keine Ausnahmen auslösen darf, wird diese Nachricht typischerweise intern als separat allokierter, referenzgezählter String gespeichert. Dies ist auch der Grund, warum es keinen Konstruktor gibt, der std::string&& akzeptiert: Der Inhalt müsste sowieso kopiert werden.

Vor der Auflösung von LWG-Problem 254 konnte der Nicht-Kopierkonstruktor nur std::string akzeptieren. Dies machte die dynamische Speicherzuweisung zur obligatorischen Erstellung eines std::string-Objekts.

Nach der Auflösung von LWG-Problem 471 muss eine abgeleitete Standard-Ausnahmeklasse einen öffentlich zugänglichen Kopierkonstruktor haben. Dieser kann implizit definiert werden, solange die durch what() erhaltenen erklärenden Zeichenketten für das ursprüngliche und das kopierte Objekt gleich sind.

std::overflow_error::operator=

overflow_error& operator=( const overflow_error& other );		(noexcept seit C++11)

Weist den Inhalt dem von other zu. Wenn *this und other beide den dynamischen Typ std::overflow_error haben, dann ist std::strcmp(what(), other.what()) == 0 nach der Zuweisung. Aus dem Kopierzuweisungsoperator kann keine Ausnahme geworfen werden.

Parameter

Sonstiges

-

ein anderes Ausnahmeobjekt zum Zuweisen

Rückgabewert

*this

Anmerkungen

Nach der Auflösung von LWG-Problem 471 muss eine abgeleitete Standard-Ausnahmeklasse einen öffentlich zugänglichen Kopierzuweisungsoperator haben. Dieser kann implizit definiert werden, solange die durch what() erhaltenen erklärenden Zeichenketten für das ursprüngliche und das zugewiesene Objekt gleich sind.

Geerbt von std::runtime_error

Abgeleitet von std::exception

Memberfunktionen

(Destruktor) [virtuell]	zerstört das Ausnahmeobjekt (virtuelle öffentliche Memberfunktion von std::exception)
what [virtuell]	gibt einen erklärenden String zurück (virtuelle öffentliche Memberfunktion von std::exception)

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <limits>
#include <stdexcept>
#include <utility>
 
template<typename T, int N>
    requires (N > 0) /*...*/
class Stack
{
    int top_{-1};
    T data_[N];
 
public:
    [[nodiscard]] bool empty() const { return top_ == -1; }
 
    void push(T x)
    {
        if (top_ == N - 1)
            throw std::overflow_error("Stack overflow!");
        data_[++top_] = std::move(x);
    }
 
    void pop()
    {
        if (empty())
            throw std::underflow_error("Stack underflow!");
        --top_;
    }
 
    T const& top() const
    {
        if (empty())
            throw std::overflow_error("Stack is empty!");
        return data_[top_];
    }
};
 
int main()
{
    Stack<int, 4> st;
 
    try
    {
        [[maybe_unused]] auto x = st.top();
    }
    catch (std::overflow_error const& ex)
    {
        std::cout << "1) Exception: " << ex.what() << '\n';
    }
 
    st.push(1337);
    while (!st.empty())
    	st.pop();
 
    try
    {
        st.pop();
    }
    catch (std::underflow_error const& ex)
    {
        std::cout << "2) Exception: " << ex.what() << '\n';
    }
 
    try
    {
        for (int i{}; i != 13; ++i)
            st.push(i);
    }
    catch (std::overflow_error const& ex)
    {
        std::cout << "3) Exception: " << ex.what() << '\n';
    }
}

Ausgabe

1) Exception: Stack is empty!
2) Exception: Stack underflow!
3) Exception: Stack overflow!

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 254	C++98	Der Konstruktor, der const char* akzeptiert, fehlte	hinzugefügt
LWG 471	C++98	die erklärenden Zeichenketten von std::overflow_error Kopien waren implementierungsabhängig	sie sind identisch mit der des ursprüngliches std::overflow_error-Objekt