#include <iostream>

using namespace std;

ostream& operator<<(ostream&,class rational); // defined later

long gcd(long x,long y) {
  while (x!=y)
    if (x>y)
      x-=y;
    else
      y-=x;
  return x;
  }

class rational {
  static int count;
  long num, den; // if num==0, den is irrelevant.  num may be negative, but not den.

public:
  rational(long n,long d);
  rational(long n): num(n),den(1) { count++; cout<<"(long)\n";}
  rational(const rational &x): num(x.num),den(x.den) { 
    count++;
    cout<<"(const rational&)\n";
    }
  rational(): num(0),den(1) { count++; cout<<"()\n";}
  ~rational() { count--; cout<<"~\n";}

  long numer() const { return num; }
  void numer(long n) { num=n;}
  long denom() const { return den; }
  void denom(long d) { den=d; }

  operator double() const {
    return num==0 ? 0.0 : ((double) num)/den;
    }

  operator int() const {
    return num==0 ? 0 : num/den;
    }

  static int instances() { return count; }

  friend rational operator+(const rational&, const rational&);
  friend rational operator-(const rational&, const rational&);
  friend rational operator*(const rational&, const rational&);
  friend rational operator/(const rational&, const rational&);

  friend rational operator+=(rational&,rational);
  friend rational operator-=(rational&,rational);

  friend rational operator++(rational&);     // prefix
  friend rational operator++(rational&,int); // postfix

  friend int operator==(const rational&,const rational&);
  friend int operator<(const rational&,const rational&);
};

int rational::count=0;

rational::rational(long n,long d) {
  if (n==0) {
    num=0;
    den=1;
    }
  else {
    long result;

    if (d==0)
      throw "zero divide";
    if ((n<0)==(d<0)) { // n and d have same sign
      if (n<0) {
        num= -n;
        den= -d;
        }
      else {
        num=n;
        den=d;
        }
      result=gcd(num,den);
      }
    else { // n and d have different signs
      if (d<0) {
        num= -n;
        den= -d;
        }
      else {
        num=n;
        den=d;
        }
      result=gcd(-num,den);
      }
    num/=result;
    den/=result;
    }
  count++;
  cout<<"(long,long)\n";
  }

rational operator+(const rational &x, const rational &y) {
  return rational(x.num*y.den+y.num*x.den,x.den*y.den);
  }

rational operator+(const rational &x) {
  return x;
  }

rational operator-(const rational &x) { return rational(-x.numer(),x.denom()); }

rational operator-(const rational &x, const rational &y) {
  return x+(-y);
  }

rational operator*(const rational &x, const rational &y) {
  return rational(x.num*y.num,x.den*y.den);
  }

rational operator/(const rational &x, const rational &y) {
  return rational(x.num*y.den,x.den*y.num);
  }

rational operator+=(rational &x,rational y) {
  x=x+y;
  return x;
  }

rational operator-=(rational &x,rational y) {
  x=x-y;
  return x;
  }

rational operator++(rational &x) { return x+=rational(1); }  // prefix

rational operator++(rational &x,int) {  // postfix
  rational save(x);
  x+=rational(1);
  return save;
  }

int operator==(const rational &x,const rational &y) {
  return x.num==y.num && x.den==y.den;
  }

int operator!=(const rational &x,const rational &y) { return !(x==y); }

int operator<(const rational &x,const rational &y) {
  return x.num*y.den<x.den*y.num;
  }

int operator>=(const rational &x,const rational &y) {
  return !(x<y);
  }

int operator>(const rational &x,const rational &y) {
  return y<x;
  }

int operator<=(const rational &x,const rational &y) {
  return !(y<x);
  }

rational operator*=(rational &x,rational y) {
  x=x*y;
  return x;
  }

rational operator/=(rational& x,rational y) {
  x=x/y;
  return x;
  }

ostream& operator<<(ostream &x,rational y) {
  return x<<y.numer()<<'/'<<y.denom();
  }

istream& operator>>(istream &x,rational &y) {
  long n,d;

  x>>n>>d;  // What about '/'?  ;)
  y=rational(n,d);
  return x;
  }

void nested_main() {
  rational x(1,2),y(3,4);
  cout<<x<<endl;
  x+=y;
  cout<<x<<endl;
  cout<<"Please enter two rationals"<<endl;
  cin>>x>>y;
  x=x+y;
  cout<<x<<endl;

  cout<<++x<<endl;
  x=rational(10,20);
  cout<<x<<endl;
  cout<<++x<<endl;
  cout<<x++<<endl;
  cout<<x++<<endl;
  cout<<rational(11,22)+rational(33,44)<<endl;
  cout<<rational(10,5)*rational(2,1)<<endl;
  cout<<+rational(111,222)<<endl;
  cout<<(rational(111,222)==rational(111,222))<<endl;
  cout<<(rational(111,222)!=rational(111,222))<<endl;
  x=rational(10,20);
  cout<<(x+=rational(3,4))<<endl;
  //cout<<rational(1,1)/rational(0,1)<<endl;
  cout<<100.0+(double) rational(10,3)<<endl; // OK?!?!?!?
  cout<<100+ (int) rational(10,3)<<endl;     // also OK
  // cout<<100.0+rational(10,3)<<endl;       // ambiguous
  cout<<(((int) rational(10,5))==((double) rational(10,4)))<<endl;
  }

int main() {
  nested_main();
  cout<<"Instances: "<<rational::instances()<<endl;
  }