Создать класс для выполнения арифметических действий с обычными дробями

#include <iostream>
#include <cassert>
 
using namespace std;
 
int gcd(int a, int b) {
    while (b > 0) {
        int c = a % b;
        a = b;
        b = c;
    }
    return a;
}
 
int lcm(int a, int b) {
    return (gcd(a, b) * a * b);
}
 
class Fraction
{
private:
    int m_numerator;
    int m_denominator;
    void reduce();
public:
    Fraction(): m_numerator(0), m_denominator(1)
    {    }
    Fraction(int numerator, int denominator=1) 
    {
        m_numerator=numerator;
        m_denominator=denominator;
        reduce();
    }
    Fraction operator=(Fraction a);
    Fraction operator+(Fraction fraction);
    Fraction operator*(Fraction fraction);
    Fraction operator/(Fraction fraction);
    friend ostream& operator<< (ostream &out, const Fraction &fr);
};
 
ostream& operator<< (ostream &out, const Fraction &fr)
{
    out << fr.m_numerator << "/" << fr.m_denominator;
    return out;
}
 
void Fraction::reduce() {
    int gcd_res = gcd(abs(m_numerator), m_denominator);
    if (gcd_res != 1) {
        m_numerator = m_numerator / gcd_res;
        m_denominator = m_denominator / gcd_res;
    }
}
 
Fraction Fraction::operator=(Fraction a)
{
    m_numerator = a.m_numerator;
    m_denominator = a.m_denominator;
    return *this;
}
 
Fraction Fraction::operator*(const Fraction fraction) {
    int n = m_numerator * fraction.m_numerator;
    int d = m_denominator * fraction.m_denominator;
    return Fraction(n,d);
}
 
Fraction Fraction::operator/(Fraction fraction) {
    int n = m_numerator * fraction.m_denominator;
    int d = m_denominator * fraction.m_numerator;
    return Fraction(n,d);
}
 
Fraction Fraction::operator+(Fraction fraction) {
    int unionDenominator = lcm(m_denominator, fraction.m_denominator);
    int relNumerator = m_numerator * fraction.m_denominator;
    int mulNumerator = fraction.m_numerator * m_denominator;
    m_numerator = relNumerator + mulNumerator;
    m_denominator = unionDenominator;
    reduce();
    return *this;
}
 
int main()
{
    Fraction a(2, 3), b(5, 6), c(3, 7), d(3, 5), res, res1, res2, res3;
    res1 = a / b; 
    res2 = c * d; 
    res3 = b / a; 
    cout << "res1=" << res1 << "  res2=" << res2 << "  res3=" << res3 << endl;
    cout << res1 + res2 + res3 << endl;
    cout << (a / b) + (c * d) + (b / a);
    return 0;
}

#include <iostream>
using namespace std;
 
class Rational
{
private:
    int numerator;
    int denominator;
    
    int gcd(int a, int b)
    {
        if (b==0) return a;
        return gcd(b,a%b);  
    }
    
    int sgn(int a)
    {
        if (a>0) return 1;
        if (a<0) return -1;
        return 0;
    }
 
public:
 
    Rational()
    {
        numerator=0;
        denominator=1;
    }
 
    Rational(int n, int d) 
    {
        int g,z;
        
        if (d==0)
        
           throw "Bad denominator";
          
        else   
        {
          z=sgn(n)*sgn(d);
          n=abs(n);
          d=abs(d);
          g=gcd(n,d);
          n=n/g;
          d=d/g;
          numerator=z*n;
          denominator=d;
        }  
          
    }
 
    //унарный +
    friend const Rational& operator+(const Rational& i);
 
    //унарный -
    friend const Rational operator-(const Rational& i);
 
    //префиксный инкремент
    friend const Rational& operator++(Rational& i);
 
    //постфиксный инкремент
    friend const Rational operator++(Rational& i, int);
 
    //префиксный декремент
    friend const Rational& operator--(Rational& i);
 
    //постфиксный декремент
    friend const Rational operator--(Rational& i, int);
 
    friend const Rational operator+(const Rational& left, const Rational& right);
    friend const Rational operator-(const Rational& left, const Rational& right);
    friend const Rational operator*(const Rational& left, const Rational& right);
    friend const Rational operator/(const Rational& left, const Rational& right);
 
    friend std::ostream& operator<< (std::ostream &out, const Rational &r);
    friend std::istream& operator>> (std::istream &in, Rational &rational);
 
    int num()
    {
        return numerator;
    }
    
    int den()
    {
        return denominator;
    }
    
};
 
    //унарный плюс ничего не делает.
    const Rational& operator+(const Rational& i) {
          return i;
    }
 
    const Rational operator-(const Rational& i) {
        int a,b;
        a=i.numerator;
        b=i.denominator;
        return Rational(-a,b);
    }
 
    //префиксная версия возвращает значение после инкремента
    const Rational& operator++(Rational& i) {
        i.numerator+=i.denominator;
        return i;
    }
 
    //постфиксная версия возвращает значение до инкремента
    const Rational operator++(Rational& i, int) {
          Rational oldValue(i.numerator,i.denominator);
          i.numerator+=i.denominator;
          return oldValue;
    }
 
    //префиксная версия возвращает значение после декремента
    const Rational& operator--(Rational& i) {
        i.numerator-=i.denominator;
        return i;
    }
 
    //постфиксная версия возвращает значение до декремента
    const Rational operator--(Rational& i,int) {
          Rational oldValue(i.numerator,i.denominator);
          i.numerator-=i.denominator;
          return oldValue;
    }
 
    const Rational operator+(const Rational& left, const Rational& right) {
        int a,b;
        b=left.denominator*right.denominator;
        a=left.denominator*right.numerator+right.denominator*left.numerator;
        return Rational(a,b);
    }
        
    const Rational operator-(const Rational& left, const Rational& right) {
        int a,b;
        b=left.denominator*right.denominator;
        a=-left.denominator*right.numerator+right.denominator*left.numerator;
        return Rational(a,b);
    }
    
    const Rational operator*(const Rational& left, const Rational& right) {
        int a,b;
        b=left.denominator*right.denominator;
        a=left.numerator*right.numerator;
        return Rational(a,b);
    }
    
    const Rational operator/(const Rational& left, const Rational& right) {
        int a,b;
        
        if (right.numerator==0)
           
           throw "ZeroDivide";
           
        else
        {
           b=left.denominator*right.numerator;
           a=left.numerator*right.denominator;
           return Rational(a,b);
        }
    }
    
    std::ostream& operator<< (std::ostream &out, const Rational &r)
    {
        if (r.denominator==1)   
           out << r.numerator;
        else   
           out << r.numerator << "/" << r.denominator;
           
        return out;
    }    
 
    std::istream& operator>> (std::istream &in, Rational &rational)
    {
 
    string s;
    string slash = "/";
    int p;
    
    in >> s;
    
    p=s.find(slash);
    
    if (p<0)
    {
        rational.numerator=atoi(s.c_str());
        rational.denominator=1;
    }
    else
    {
        rational.numerator=atoi(s.substr(0,p).c_str());
        rational.denominator=atoi(s.substr(p+1).c_str());
    }
 
    return in;
}
 
int main()
{
    Rational r1;
    Rational r2;
 
    cout << "a=";
    cin  >> r1;
    
    cout << "b=";
    cin  >> r2;
 
    try
    {
       cout << "a+b=" << r1+r2 << " a-b=" << r1-r2 << endl;
       cout << "a*b=" << r1*r2 << " a/b=" << r1/r2 << endl;
    }
    catch(const char *msg)
    {
       cout << endl << msg << endl;  
    }
    
    return 0;
}