Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::overflow_error — signaler un dépassement arithmétique

std::overflow_error, déclaré dans <stdexcept>, sert à signaler un dépassement arithmétique. Il ne détecte pas automatiquement les dépassements : le code doit vérifier les limites avant une opération risquée et lever explicitement l’exception.

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

Syntaxe

#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 est un type d’exception déclaré dans <stdexcept> qui permet de signaler un dépassement arithmétique. Il dérive publiquement de std::runtime_error et indirectement de std::exception ; il peut donc aussi être intercepté par une référence à l’une de ces classes de base.

Ses constructeurs explicit acceptent un message sous la forme const std::string& ou const char*. La méthode héritée what() expose ce message sous la forme d’une chaîne terminée par un caractère nul, qui est égale au texte fourni lors d’une comparaison. L’interception par const std::overflow_error& permet de lire le message sans copier l’exception.

L’utilisation de ce type n’active pas la vérification arithmétique. Un dépassement dans l’arithmétique entière signée intégrée entraîne un comportement indéfini ; try/catch ne le transforme pas en exception. L’arithmétique non signée fonctionne modulo 2^N et ne lance pas non plus automatiquement std::overflow_error. Vérifiez les limites avant l’opération, plutôt que de vérifier uniquement son résultat.

L’exemple vérifie si l’incrémentation d’un int dépasserait sa valeur maximale. Si c’est le cas, il lance explicitement une exception avant d’évaluer value + 1, et le gestionnaire affiche integer overflow. Cette fiche concerne C++23 ; le projet de norme évolutif fourni peut présenter des ajouts ultérieurs, c’est pourquoi la syntaxe ne marque pas les constructeurs constexpr.

Exemples

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

Résultat

integer overflow

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources