Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::overflow_error — segnalare un overflow aritmetico

std::overflow_error, dichiarato in <stdexcept>, serve a segnalare un overflow aritmetico. Non rileva automaticamente gli overflow: il codice deve controllare i limiti prima di un’operazione rischiosa e lanciare esplicitamente l’eccezione.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#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 è un tipo di eccezione dichiarato in <stdexcept> che serve a segnalare un overflow aritmetico. Deriva pubblicamente da std::runtime_error e indirettamente da std::exception, quindi può essere intercettato anche tramite un riferimento a una di queste classi base.

I suoi costruttori explicit accettano un messaggio come const std::string& o const char*. Il metodo ereditato what() espone il messaggio come stringa terminata da un carattere nullo, che risulta uguale al testo fornito quando viene confrontata. Intercettare tramite const std::overflow_error& consente di leggere il messaggio senza copiare l’eccezione.

L’uso di questo tipo non attiva controlli aritmetici. Un overflow nell’aritmetica intera con segno integrata ha comportamento indefinito; try/catch non lo trasforma in un’eccezione. L’aritmetica senza segno opera modulo 2^N e non lancia automaticamente std::overflow_error. Controlla i limiti prima dell’operazione, anziché verificare soltanto il risultato.

L’esempio controlla se incrementare un int ne supererebbe il valore massimo. In tal caso, lancia esplicitamente un’eccezione prima di valutare value + 1, e il gestore stampa integer overflow. Questa voce riguarda C++23; la bozza evolutiva dello standard fornita può mostrare aggiunte successive, perciò la sintassi non indica i costruttori come constexpr.

Esempi

#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';
    }
}

Risultato

integer overflow

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti