Namespaces
Variants

std:: overflow_error

From cppreference.net
C++
Diagnostics library
Definido en el encabezado <stdexcept>
class overflow_error ;

Define un tipo de objeto que se lanzará como excepción. Se puede utilizar para informar errores de desbordamiento aritmético (es decir, situaciones donde el resultado de un cálculo es demasiado grande para el tipo de destino).

El único componente de la biblioteca estándar que lanza esta excepción es std::bitset::to_ulong .

(until C++11)

Los únicos componentes de la biblioteca estándar que lanzan esta excepción son std::bitset::to_ulong y std::bitset::to_ullong .

(since C++11)

Las funciones matemáticas de los componentes de la biblioteca estándar no lanzan esta excepción (las funciones matemáticas reportan errores de desbordamiento como se especifica en math_errhandling ). Sin embargo, las bibliotecas de terceros utilizan esto. Por ejemplo, boost.math lanza std::overflow_error si boost::math::policies::throw_on_error está habilitado (la configuración predeterminada).

Todas las funciones miembro de std::overflow_error son constexpr : es posible crear y utilizar objetos std::overflow_error en la evaluación de una expresión constante.

Sin embargo, std::overflow_error generalmente no puede ser constexpr , porque cualquier almacenamiento asignado dinámicamente debe liberarse en la misma evaluación de la expresión constante.

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

Diagrama de herencia

Contenidos

Funciones miembro

(constructor)
construye un nuevo objeto overflow_error con el mensaje dado
(función miembro pública)
operator=
reemplaza el objeto overflow_error
(función miembro pública)

std::overflow_error:: overflow_error

overflow_error ( const std:: string & what_arg ) ;
(1) (constexpr desde C++26)
overflow_error ( const char * what_arg ) ;
(2) (constexpr desde C++26)
overflow_error ( const overflow_error & other ) ;
(3) (noexcept desde C++11)
(constexpr desde C++26)
1) Construye el objeto de excepción con what_arg como cadena explicativa. Después de la construcción, std:: strcmp ( what ( ) , what_arg. c_str ( ) ) == 0 .
2) Construye el objeto de excepción con what_arg como cadena explicativa. Después de la construcción, std:: strcmp ( what ( ) , what_arg ) == 0 .
3) Constructor de copia. Si * this y other ambos tienen tipo dinámico std::overflow_error entonces std:: strcmp ( what ( ) , other. what ( ) ) == 0 . Ninguna excepción puede ser lanzada desde el constructor de copia.

Parámetros

what_arg - cadena explicativa
other - otro objeto de excepción a copiar

Excepciones

1,2) Puede lanzar std::bad_alloc .

Notas

Debido a que copiar std::overflow_error no está permitido lanzar excepciones, este mensaje normalmente se almacena internamente como una cadena con conteo de referencias asignada por separado. Esta es también la razón por la cual no hay un constructor que tome std::string&& : tendría que copiar el contenido de todos modos.

Antes de la resolución de LWG issue 254 , el constructor no copia solo puede aceptar std::string . Esto hace que la asignación dinámica sea obligatoria para construir un objeto std::string .

Después de la resolución de LWG issue 471 , una clase de excepción estándar derivada debe tener un constructor de copia públicamente accesible. Puede estar definido implícitamente siempre que las cadenas explicativas obtenidas por what() sean las mismas para el objeto original y el objeto copiado.

std::overflow_error:: operator=

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

Asigna los contenidos con los de other . Si * this y other tienen ambos el tipo dinámico std::overflow_error entonces std:: strcmp ( what ( ) , other. what ( ) ) == 0 después de la asignación. Ninguna excepción puede ser lanzada desde el operador de asignación de copia.

Parámetros

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

Valor de retorno

* this

Notas

Después de la resolución de LWG issue 471 , una clase de excepción estándar derivada debe tener un operador de asignación de copia públicamente accesible. Puede estar definido implícitamente siempre que las cadenas explicativas obtenidas por what() sean las mismas para el objeto original y el objeto copiado.

Heredado de std:: runtime_error


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 Estándar Característica
__cpp_lib_constexpr_exceptions 202502L (C++26) constexpr tipos de excepción

Ejemplo

Ejecutar este código 
#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';
    }
}

Salida: 

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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Se aplica a Comportamiento publicado Comportamiento correcto
LWG 254 C++98 faltaba el constructor que acepta const char * añadido
LWG 471 C++98 las cadenas explicativas de las copias de std::overflow_error
estaban definidas por la implementación 		son las mismas que las del objeto
original de std::overflow_error