C++ Recursion and Exception Handling with Fibonacci Sequence

Question

This program seems to work for the Fibonacci Sequence using recursion and exception handling. (Yes I want to do it with recursion, I know I can use loops).

It is supposed to throw an error if the next result is out of range for long long. Which it works, if I put in most numbers, but if I put in number 91, it shows one negative result without printing the error message. If I put in 89, 90, 92, 93, ... it works fine.

Why 91?

Output of 91:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170 1836311903 2971215073 4807526976 7778742049 12586269025 20365011074 32951280099 53316291173 86267571272 139583862445 225851433717 365435296162 591286729879 956722026041 1548008755920 2504730781961 4052739537881 6557470319842 10610209857723 17167680177565 27777890035288 44945570212853 72723460248141 117669030460994 190392490709135 308061521170129 498454011879264 806515533049393 1304969544928657 2111485077978050 3416454622906707 5527939700884757 8944394323791464 14472334024676221 23416728348467685 37889062373143906 61305790721611591 99194853094755497 160500643816367088 259695496911122585 420196140727489673 679891637638612258 1100087778366101931 1779979416004714189 2880067194370816120 4660046610375530309 -6246583658587674878

CPP Program:

#include <iostream>

using std::cout;
using std::cin;
using std::endl;
using std::cerr;

#include <stdexcept>
using std::out_of_range;

#include <climits>

class OUTofRage : public out_of_range
{
   public:
      OUTofRage()
          : out_of_range("Out Of Range\n") {}
} ;

long long fibonacci(long long target, long long numberOne, long long numberTwo);

int main() {
    long long fiboSub;
    cout << "--fibonacci Sequencer--\n" << endl;

    cout << "Which place in the fibonacci sequence do you want to reach (F(n))?\n";
    cout << "n> ";
    cin >> fiboSub;
    
    cout << endl << fibonacci(fiboSub, 0, 1) << endl << endl;
    return 0;
}

long long fibonacci(long long target, long long numberOne, long long numberTwo) {
    cout << numberOne << " ";

    if(target < 0) {
        throw OUTofRage();
    } else if(target == 0) {
        return numberOne + numberTwo;
    } else {
        try {
            if((numberOne + numberTwo) < 0) {
                throw OUTofRage();
            } else {
                fibonacci(target-1, numberTwo, numberOne + numberTwo);
            }
        }
        catch (const out_of_range& O_O_R) {
            cerr << endl << "\nError: " << O_O_R.what() << '\n';
            exit (EXIT_FAILURE);
        }
    }
}

Your overflow check is not correct. If you add two signed integral types and the result overflows, then your program has undefined behavior. It is too late to do anything about it at that point. There are no guarantees anymore about how the program will behave. You need to make sure that `numberOne + numberTwo` doesn't overflow _before_ you perform the addition. Also, that expression appears twice, but only in one case are you performing a check at all. — user17732522, Sep 15 '22 at 03:32
As for all the exception stuff, I don't really see the point. It seems that you immediately catch the thrown exception again in the same function only to then terminate the program. Why do you not simply terminate the program immediately where the overflow is detected? — user17732522, Sep 15 '22 at 03:34
This is not the normal way to implement this with recursion. It is more efficient than the standard recursive version though. — Martin York, Sep 15 '22 at 04:02

Slava · Accepted Answer · 2022-09-15T04:09:48.873

This line of code is invalid:

if((numberOne + numberTwo) < 0)

per Is signed integer overflow still undefined behavior in C++? you are relying on Undefined Behaviour, which is a mistake. You can replace your condition with:

if( std::numeric_limits<long long>::max() - numberOne < numberTwo )

or more generic:

if( std::numeric_limits<decltype(numberOne)>::max() - numberOne < numberTwo )

which does not overflow and will give you predictable result. For this to work, you also cannot keep this condition as it is, without checking for overflow first:

if(target == 0) {
    return numberOne + numberTwo;

as it relies on the same problem. So here how your function could look like:

long long fibonacci(long long target, long long numberOne, long long numberTwo)
{
    // check for overflow first
    if(std::numeric_limits<decltype(numberOne)>::max() - numberOne < numberTwo) 
         throw OUTofRage();

    if(target == 0) 
        return numberOne + numberTwo;
        
    return fibonacci(target-1, numberTwo, numberOne + numberTwo);
}

Live example

PS on this line:

            fibonacci(target-1, numberTwo, numberOne + numberTwo);

you are missing return statement

Doing either of those two suggestions still gives me the same output. — Sorted Sand, Sep 15 '22 at 04:06

C++ Recursion and Exception Handling with Fibonacci Sequence

1 Answers1