#include <iostream>
#include <stdlib.h>
using namespace std;

inline int NOD(int a,int b)
 {
   a = abs(a);b = abs(b);
    while(a!=0 && b!=0)
    {
       if(a>=b) a=a%b;
           else b=b%a;
    }
    return a+b; // Одно - ноль
 }

class fraction
{
private:
  signed int* divider;
  int* denominator;
public:
  fraction(int, int);
  fraction();
  fraction(int);
  ~fraction();
  void print();
  fraction* reduction();
  void operator=(fraction& );
  bool operator==(fraction&);
  bool operator>(fraction& );
  bool operator>=(fraction& );
  bool operator<(fraction& );
  bool operator<=(fraction& );
  bool operator!=(fraction&);
  fraction* operator+(fraction& );
  fraction* operator-(fraction& );
  fraction* operator-();
  fraction* operator*(fraction&);
  fraction* operator/(fraction&);
  
};

fraction* fraction::reduction()
{
  fraction* a;
  int nod = NOD(*divider, *denominator);
  a = new fraction(*divider / nod, *denominator / nod);
  return a;
  
}


void fraction::print()
{
  cout<< *divider <<  "/" << *denominator << endl;
}

fraction::fraction()
{
  *divider = 0;
  *denominator = 1;
}

fraction::fraction(int a)
{
  *divider = a;
  *denominator = 1;
}


fraction::fraction(int div, int den)
{
  divider = new int;
  denominator = new int;
  *divider = div;
  *denominator = den;
};

fraction::~fraction()
{
  delete divider;
  delete denominator;
};

fraction* fraction::operator*(fraction& a)
{
  fraction *b;
  b = new fraction( *divider * *a.divider, *denominator * *a.denominator);
  return b->reduction();
}

fraction* fraction::operator/(fraction& a)
{
  fraction *b;
  b = new fraction( *divider * *a.denominator, *denominator * *a.divider);
  return b->reduction();
}


fraction* fraction::operator-()
{
  fraction *b;
  return b = new fraction(-*divider, *denominator);
}

void fraction::operator=(fraction& a)
{
  *divider = *a.divider;
  *denominator = *a.denominator;
}

fraction* fraction::operator+(fraction& a)
{
  //int newdiv, newden;
  fraction* b;
  //b = new fraction(0,1);
  
  if (*denominator == *a.denominator)
    {  
      b = new fraction(*divider + *a.divider,  *denominator);
    }
  else
    {
      b = new fraction(*denominator * *a.divider +
         *divider * *a.denominator,
         *denominator * *a.denominator);
    }
  return b->reduction();
}
fraction* fraction::operator-(fraction& a)
{
  fraction* b;
  if (*denominator == *a.denominator)
    {
      b = new fraction(*divider - *a.divider, *denominator);
    }
  else
    {
      b = new fraction(*divider * *a.denominator - *denominator * *a.divider, 
         *denominator * *a.denominator);
    }
  return b->reduction();
}

//операторы сравнения
bool fraction::operator ==(fraction& a)
{
  int nod1 = NOD(*divider, *denominator);
  int nod2 = NOD(*a.divider, *a.denominator);
  if ((*divider/nod1 == *a.divider/nod2) && (*denominator/nod1 == *a.denominator/nod2))
    return true;
  else
    return false;
  //сделать через НОД
};


bool fraction::operator >(fraction& a)
{
   if ((*divider * *a.denominator) > (*denominator * *a.divider))
    return true;
  else
    return false;
};

bool fraction::operator >=(fraction& a)
{
  if (*this == a)
    return true;
  else if (*this > a )
     return true;
  else
    return false;
};

bool fraction::operator <(fraction& a)
{
  if (!(*this > a))
    return true;
  else
    return false;
}

bool fraction::operator <=(fraction& a)
{
  if ((*this < a) || (*this == a))
    return true;
  else
    return false;
};
bool fraction::operator !=(fraction& a)
{
  if (!(*this == a))
    return true;
  else
    return false;
};

int main()
{
  fraction *a, *b, *c, *d;
  a = new fraction(1, 524);
  b = new fraction(20, 513);
  (*a + *b)->print();
  (*a - *b)->print();
  (*a * *b)->print();
  (*a / *b)->print();
  ( - *b)->print();
  (*a + (-(*b)))->print();
}