Namespaces
Variants

std:: overflow_error

From cppreference.net
C++
Diagnostics library
Défini dans l'en-tête <stdexcept>
class overflow_error ;

Définit un type d'objet à lancer comme exception. Il peut être utilisé pour signaler des erreurs de dépassement arithmétique (c'est-à-dire des situations où le résultat d'un calcul est trop grand pour le type de destination).

Le seul composant de la bibliothèque standard qui lance cette exception est std::bitset::to_ulong .

(jusqu'en C++11)

Les seuls composants de la bibliothèque standard qui lancent cette exception sont std::bitset::to_ulong et std::bitset::to_ullong .

(depuis C++11)

Les fonctions mathématiques des composants de la bibliothèque standard ne lèvent pas cette exception (les fonctions mathématiques signalent les erreurs de dépassement de capacité comme spécifié dans math_errhandling ). Cependant, les bibliothèques tierces l'utilisent. Par exemple, boost.math lève std::overflow_error si boost::math::policies::throw_on_error est activé (paramètre par défaut).

Toutes les fonctions membres de std::overflow_error sont constexpr : il est possible de créer et d'utiliser des objets std::overflow_error dans l'évaluation d'une expression constante.

Cependant, les objets std::overflow_error ne peuvent généralement pas être constexpr , car tout stockage alloué dynamiquement doit être libéré dans la même évaluation de l'expression constante.

(depuis C++26)
cpp/error/exception cpp/error/runtime error std-overflow error-inheritance.svg

Diagramme d'héritage

Table des matières

Fonctions membres

(constructeur)
construit un nouvel objet overflow_error avec le message donné
(fonction membre publique)
operator=
remplace l'objet overflow_error
(fonction membre publique)

std::overflow_error:: overflow_error

overflow_error ( const std:: string & what_arg ) ;
(1) (constexpr depuis C++26)
overflow_error ( const char * what_arg ) ;
(2) (constexpr depuis C++26)
overflow_error ( const overflow_error & other ) ;
(3) (noexcept depuis C++11)
(constexpr depuis C++26)
1) Construit l'objet d'exception avec what_arg comme chaîne explicative. Après construction, std:: strcmp ( what ( ) , what_arg. c_str ( ) ) == 0 .
2) Construit l'objet d'exception avec what_arg comme chaîne explicative. Après construction, std:: strcmp ( what ( ) , what_arg ) == 0 .
3) Constructeur de copie. Si * this et other ont tous deux le type dynamique std::overflow_error alors std:: strcmp ( what ( ) , other. what ( ) ) == 0 . Aucune exception ne peut être levée depuis le constructeur de copie.

Paramètres

what_arg - chaîne explicative
other - autre objet d'exception à copier

Exceptions

1,2) Peut lever std::bad_alloc .

Notes

Comme la copie de std::overflow_error n'est pas autorisée à lever des exceptions, ce message est généralement stocké en interne sous forme de chaîne à comptage de référence allouée séparément. C'est aussi pourquoi il n'y a pas de constructeur prenant std::string&& : il devrait de toute façon copier le contenu.

Avant la résolution de LWG issue 254 , le constructeur non-copie ne pouvait accepter que std::string . Cela rendait l'allocation dynamique obligatoire pour construire un objet std::string .

Après la résolution de LWG issue 471 , une classe d'exception standard dérivée doit avoir un constructeur de copie accessible publiquement. Il peut être implicitement défini tant que les chaînes explicatives obtenues par what() sont identiques pour l'objet original et l'objet copié.

std::overflow_error:: operator=

overflow_error & operator = ( const overflow_error & 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::overflow_error alors std:: strcmp ( what ( ) , other. what ( ) ) == 0 après l'assignation. Aucune exception ne peut être levée par l'opérateur d'assignation de copie.

Paramètres

other - un autre objet exception à assigner

Valeur de retour

* this

Notes

Après la résolution de LWG issue 471 , une classe d'exception standard dérivée doit avoir un opérateur d'assignation de copie accessible publiquement. Il peut être défini implicitement tant que les chaînes explicatives obtenues par what() sont les mêmes pour l'objet original et l'objet copié.

Hérité de std:: runtime_error


Hérité de std:: exception

Fonctions membres

[virtual]
détruit l'objet exception
(fonction membre publique virtuelle de std::exception )
[virtual]
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 202502L (C++26) constexpr types d'exception

Exemple

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

Sortie : 

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 254 C++98 le constructeur acceptant const char * était manquant ajouté
LWG 471 C++98 les chaînes explicatives des
copies de std::overflow_error étaient définies par l'implémentation 		elles sont identiques à celles de
l'objet std::overflow_error original