#include <iostream>

// demo operator overloading, not meant to be a full fraction class

class Fraction 
{
public:
  Fraction() : num (0), denom(1) {}

  Fraction(int x, int y = 1) : num(x), denom(y) {}

  Fraction(const Fraction& other) : num(other.num), denom(other.denom) {}

  Fraction& operator=(const Fraction& rhs)
  {
    num = rhs.num;
    denom = rhs.denom;
    return *this;
  }

  Fraction operator+(const Fraction& rhs) const
  {
    if ( denom == rhs.denom)
    {
      return Fraction(num+rhs.num, denom);
    }

    int tmp_d = denom * rhs.denom;
    int tmp_n = (num * rhs.denom) + (rhs.num * denom);
    return Fraction(tmp_n, tmp_d); 
  }

  Fraction operator+(const int rhs) const
  {
    return *this + Fraction(rhs);
  }

  Fraction& operator+=(const Fraction& rhs)
  {
    *this = *this + rhs;
    return *this;
  }

  bool operator==(const Fraction& rhs)const
  {
    if ((num == rhs.num) && (denom == rhs.denom))
      return true;
    else
      return false;
  }

  friend std::ostream& operator<<(std::ostream&, const Fraction&);

private:
  int num;
  int denom;
};

Fraction operator+(int lhs, const Fraction &obj)
{
  return Fraction(lhs) + obj;
}

std::ostream& operator<<(std::ostream &os,const Fraction &obj)
{
  os << obj.num << "/" << obj.denom;
  return os;
}

int main(int argc, char** argv)
{
  Fraction f1 = 5;
  Fraction f2(3,8);
  Fraction f3;
  Fraction f4(46,8);
  Fraction f5;

  f3 = f1 + f2;
  std::cout << f1 << " + " << f2 << " = " << f3 << std::endl;

  f3 += f2;
  std::cout << "new f3: " << f3 << std::endl;

  std::cout << f2 << " == " << f3 << (f2==f3?" true":" false") << std::endl;
  std::cout << f3 << " == " << f4 << (f3==f4?" true":" false") << std::endl;

  f5 = f2 + 6;
  std::cout << f2 << " + 6 = " << f5 << std::endl;

  f5 = 6 + f2;
  std::cout <<  "6 + " << f2 << "  = " << f5 << std::endl;

  return 0;
}