Throw-oriented programming


#include <iostream>

using std::cout;
using std::endl;

class Integer
{
public:
     Integer( int i ) : i_( i ) {}
     operator int() { return i_; }

protected:
     int i_;
};

class Fibonacci : public Integer
{
public:
     Fibonacci( int i );
};

Fibonacci::Fibonacci( int i ) : Integer( i )
{
     try {
          if ( i == 0 || i == 1 ) {
               throw Integer( i );
          } else {
               throw Integer( Fibonacci( i - 1 ) + Fibonacci( i - 2 ) );
          }
     } catch ( Integer ex ) {
          i_ = ex;
     }
}

int main()
{
     const int UNTIL = 20;
     for ( int loop = 0; loop < UNTIL; ++loop ) {
          Fibonacci fibo( loop );
          cout << fibo << ' ';
     }
     cout << endl;
     return 0;
}

Lets take it up a notch.

template<int at> struct Fib
{
  static const uint64_t value = Fib<at-1>::value + Fib<at-2>::value;
  static inline uint64_t getValue(int i)
  {
    if (i == at)
      return value;
    return Fib<at-1>::getValue(i);
  }
};
 
template<> struct Fib<0>
{
  static const uint64_t value = 1;
  static inline uint64_t getValue(int i)
  {
    return 1;
  }
};
 
template<> struct Fib<1>
{
  static const uint64_t value = 1;
  static inline uint64_t getValue(int i)
  {
    if (i == 1)
      return value;
    return Fib<0>::getValue(i);
  }
};


int main(int, char *[])
{
  for (int i = 0; i < 20; i ++)
    std::cout << Fib<20>::getValue(i) << std::endl;
}