Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::overflow_error — informar de un desbordamiento aritmético

std::overflow_error, declarado en <stdexcept>, sirve para informar de un desbordamiento aritmético. No detecta los desbordamientos automáticamente: el código debe comprobar los límites antes de una operación arriesgada y lanzar la excepción de forma explícita.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#include <stdexcept>

// Constructor declarations in <stdexcept> (abridged):
// namespace std {
// class overflow_error : public runtime_error {
// public:
//     explicit overflow_error(const std::string& what_arg);
//     explicit overflow_error(const char* what_arg);
// };
// }

throw std::overflow_error("integer overflow");

std::overflow_error es un tipo de excepción declarado en <stdexcept> que se utiliza para informar de un desbordamiento aritmético. Deriva públicamente de std::runtime_error e indirectamente de std::exception, por lo que también se puede capturar mediante una referencia a cualquiera de esas clases base.

Sus constructores explicit aceptan un mensaje como const std::string& o const char*. El método heredado what() proporciona el mensaje como una cadena terminada en nulo, que se compara como igual al texto proporcionado. Capturar mediante const std::overflow_error& permite leer el mensaje sin copiar la excepción.

Usar este tipo no activa la comprobación aritmética. Un desbordamiento en la aritmética entera con signo integrada tiene comportamiento indefinido; try/catch no lo convierte en una excepción. La aritmética sin signo opera módulo 2^N y tampoco lanza automáticamente std::overflow_error. Comprueba los límites antes de la operación, en lugar de comprobar únicamente su resultado.

El ejemplo comprueba si incrementar un int superaría su valor máximo. Si es así, lanza explícitamente una excepción antes de evaluar value + 1, y el manejador imprime integer overflow. Esta entrada se refiere a C++23; el borrador vivo de la norma proporcionado puede incluir adiciones posteriores, por lo que la sintaxis no marca los constructores como constexpr.

Ejemplos

#include <iostream>
#include <limits>
#include <stdexcept>

int checked_increment(int value) {
    if (value == std::numeric_limits<int>::max()) {
        throw std::overflow_error("integer overflow");
    }
    return value + 1;
}

int main() {
    try {
        const int result = checked_increment(std::numeric_limits<int>::max());
        std::cout << result << '\n';
    } catch (const std::overflow_error& error) {
        std::cout << error.what() << '\n';
    }
}

Resultado

integer overflow

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes