fractionClassOperatorsOverloading

#include <iostream>

class Fraction
{
    int num;
    int denom;
    friend Fraction operator*(const Fraction &lhs, const Fraction &rhs);
    friend Fraction operator/(const Fraction &lhs, const Fraction &rhs);
    friend Fraction operator+(const Fraction &lhs, const Fraction &rhs);
    friend Fraction operator-(const Fraction &lhs, const Fraction &rhs);
    friend bool operator==(const Fraction &lhs, const Fraction &rhs);
    friend bool operator!=(const Fraction &lhs, const Fraction &rhs);
    friend std::ostream& operator<<(std::ostream &out, const Fraction &rhs);
    friend std::istream& operator>>(std::istream &in, Fraction &rhs);
    int gcd(int a, int b);
    void reduce();

public:
    Fraction() : Fraction(0, 1) {};
    Fraction(int n) : Fraction(n, 1){};
    Fraction(int n, int d);
//  Fraction& operator=(const Fraction &rhs);
    Fraction& operator*=(const Fraction &rhs);
    Fraction& operator/=(const Fraction &rhs);
    Fraction& operator+=(const Fraction &rhs);
    Fraction& operator-=(const Fraction &rhs);
    Fraction& operator++();
    Fraction& operator--();
    Fraction operator++(int);
    Fraction operator--(int);
};

Fraction::Fraction(int n, int d)
: num{ n }, denom{ d ? d : 1 }
{
    reduce();
}

int Fraction::gcd(int a, int b)
{
    while (b)
    {
        a %= b;
        std::swap(a, b);
    }
    return a;
}

void Fraction::reduce()
{
    int gcdVal
    { gcd(num, denom) };
    num /= gcdVal;
    denom /= gcdVal;
    if (denom < 0 and num < 0)
    {
        denom *= -1;
        num *= -1;
    }
}

Fraction& Fraction::operator++()
{
    num+=denom;
    return *this;
}

Fraction& Fraction::operator--()
{
    num-=denom;
    return *this;
}

Fraction Fraction::operator++(int)
{
    Fraction tmp{*this};
    ++(*this);
    return tmp;
}

Fraction Fraction::operator--(int)
{
    Fraction tmp{*this};
    --(*this);
    return tmp;
}

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

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

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


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


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

Fraction operator*(const Fraction &lhs, const Fraction &rhs)
{
    return Fraction{ lhs.num * rhs.num, lhs.denom * rhs.denom };
}

Fraction operator/(const Fraction &lhs, const Fraction &rhs)
{
    return Fraction{ lhs.num * rhs.denom, lhs.denom * rhs.num };
}

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

Fraction operator-(const Fraction &lhs, const Fraction &rhs)
{
    return Fraction(lhs.num * rhs.denom - rhs.num * lhs.denom, rhs.denom * lhs.denom);
}

std::ostream& operator<<(std::ostream &out, const Fraction &rhs)
{
    if (rhs.num == rhs.denom)
    {
        out << 1;
        return out;
    }

    if (rhs.denom == 1)
    {
        out << rhs.num;
        return out;
    }

    out << rhs.num << '/' << rhs.denom;
    return out;
}

std::istream& operator>>(std::istream &in, Fraction &rhs)
{
    in >> rhs.num;
    in >> rhs.denom;
    rhs.denom = (rhs.denom ? rhs.denom : 1);
    rhs.reduce();
    return in;
}

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

bool operator!=(const Fraction &lhs, const Fraction &rhs)
{
    return !(lhs == rhs);
}

int main()
{
    Fraction a{ 3, 5 };
    Fraction b{ 1, 3 };
    Fraction c{ 2, 3 };
    Fraction a1{ 3, 5 };
    Fraction d{};

    d = c;
    std::cout << "d = " << d << '\n';
    std::cout << "d += b " << (d += b) << '\n';
    std::cout << a << ' ' << b << '\n';
    std::cout << a + b << '\n';
    std::cout << a - b << '\n';
    std::cout << (a == a1) << '\n';
    b+=c;
    std::cout << "b=" << b << '\n';
    b-=c;
    std::cout << "b=" << b << '\n';
    std::cout << "++b = " << (++b) << " --b = " << --b << '\n';
    std::cout << "b++ = " << (b++) << " b-- = " << b-- << " b = " << b << '\n';
    std::cin >> a >> a1;
    std::cout << a << ' ' << a1 << '\n';
    std::cout << a << " == " << a1 << " : " << (a == a1) << '\n';
    std::cout << a << " != " << a1 << " : " << (a != a1) << '\n';
}