Is overflow_error caught at runtime in C++ when a integer variable cannot hold a value that it is not supposed to

Question

I am learning C++, I was trying to write this function to find the largest fibonacci integer that can fit into an integer type:

void findFibThatFitsInAnInt()
{
    int n1 = 1;
    int n2 = 1;
    int fib = 0;
    try
    {
        while ( true )
        {
            fib = n1 + n2;
            n1 = n2;
            n2 = fib;
            cout << "Fibonacci number : " << fib << "\n";
        } 

    }
    catch (overflow_error & e)
    {
        cout << "The largest fib that can fit into an int is : " << fib << "\n";
        cout << e.what() << "\n";
    }

    cout << "The largest fib that can fit into an int is : " << n1 << "\n";
}

But the thing is overflow_error is not caught at all. I know other ways of doing this:

I know that I can write like :

while ( fib >= 0 )
        {
            fib = n1 + n2;
            n1 = n2;
            n2 = fib;
            cout << "Fibonacci number : " << fib << "\n";
        } 

and because fib is just an "int" not an unsigned int, it will eventually become < 0 ( strangely enough ) when it is assigned a value that is larger than the capacity of int type.

Question is : is overflow_error for this kind of capacity issue caught at runtime in C++? Did I misunderstand something about overflow_error? This is what I know from my google foo:

Defines a type of object to be thrown as exception. It can be used to report arithmetic overflow errors (that is, situations where a result of a computation is too large for the destination type)

If overflow_error is ignored for integer overflows is there a way to enable it for my c++ compiler ( visual studio 2013?)

Answer 1

Short answer: No. Neither C nor C++ will automatically detect integer overflow at runtime.

Here are more details about C++ std::overflow_error:

http://en.cppreference.com/w/cpp/error/overflow_error

std::overflow_error Defined in header <stdexcept>

Defines a type of object to be thrown as exception. It can be used to report arithmetic overflow errors (that is, situations where a result of a computation is too large for the destination type)

The only standard library components that throw this exception are std::bitset::to_ulong and std::bitset::to_ullong.

The mathematical functions of the standard library components do not throw this exception (mathematical functions report overflow errors as specified in math_errhandling). Third-party libraries, however, use this. For example, boost.math throws std::overflow_error if boost::math::policies::throw_on_error is enabled (the default setting).

Here is more information about what you can do in your code to detect and handle integer overflow:

How to detect integer overflow?

Answer 2

According to the standard (emphasis mine):

5 Expressions [expr]
....

If during the evaluation of an expression, the result is not mathematically defined or not in the range of representable values for its type, the behavior is undefined. [ Note: most existing implementations of C++ ignore integer overflows.

P.S. BTW, please note that

3.9.1 Fundamental types [basic.fundamental]
....

(footnote)
unsigned arithmetic does not overflow because a result that cannot be represented by the resulting unsigned integer type is reduced modulo the number that is one greater than the largest value that can be represented by the resulting unsigned integer type.

Answer 3

is overflow_error for this kind of capacity issue caught at runtime in C++?

No, as from the documentation

The only standard library components that throw this exception are std::bitset::to_ulong and std::bitset::to_ullong.

Overflows as induced by intrinsic mathematical operations won't be caught, and just leave you with unexpected results. The exact behavior isn't defined in the standard (great cite in @AlexD 's answer).