PV913ClassesFractionOperatorOverloading

#include <iostream>

//class GoodClass
//{
//    int secret;
//
//public:
//    void badMethod() {};
//    void niceMethod(Fraction& fract) { fract.denominator = 5; };
//
//};

class Fraction
{
    int numerator;
    int denominator;
    int gcd(int a, int b);
    void reduce();
public:
    Fraction(const Fraction& fract)
        : numerator{ fract.numerator }, denominator{ fract.denominator }
    {
        reduce();
        std::cout << "Fraction COPY constructed for " << this << '\n';
    };
    Fraction(int num, int denom)
        : numerator{ num }, denominator{ denom ? denom : 1 }
    {
        reduce();
        std::cout << "Fraction constructed for " << this << '\n';
    };
    Fraction() : Fraction(1, 1) {};
    ~Fraction() { std::cout << "Fraction destructed for " << this << '\n'; };
    void setNumerator(int num) { numerator = num; reduce(); };
    int getNumerator() const { return numerator; };
    void setDenominator(int denom) { denominator = denom ? denom : 1; reduce(); };
    int getDenominator() const { return denominator; };
    void print() const;
    Fraction& mul(const Fraction fract) { numerator *= fract.numerator; denominator *= fract.denominator; return *this; };
    Fraction& mul(int num) { numerator *= num; return *this; };
    Fraction& div(const Fraction fract) { numerator *= fract.denominator; denominator *= fract.numerator; return *this; };
    Fraction& div(int num) { denominator *= num; return *this; };
    //Fraction operator*(const Fraction& rhs) const;
    friend Fraction operator*(const Fraction& lhs, const Fraction& rhs); // a * b
    friend Fraction operator*(const Fraction& lhs, int rhs); // a * x
    friend Fraction operator*(int lhs, const Fraction& rhs); // y * b
    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 std::ostream& operator<<(std::ostream& out, const Fraction& rhs);
    //friend std::istream& operator>>(std::istream& in, Fraction& rhs);
};

//Fraction Fraction::operator*(const Fraction& rhs) const
//{
//   return Fraction{ numerator * rhs.numerator,  denominator * rhs.denominator };
//}

Fraction operator*(const Fraction& lhs, const Fraction& rhs)
{
    return Fraction{ lhs.numerator * rhs.numerator,  lhs.denominator * rhs.denominator };
}

Fraction operator*(const Fraction& lhs, int rhs)
{
    return Fraction{ lhs.numerator * rhs,  lhs.denominator };
}

Fraction operator*(int lhs, const Fraction& rhs)
{
    return rhs * lhs;
}

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

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

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

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

//std::ostream& operator<<(std::ostream& out, const Fraction& rhs)
//{
//    out << '(' << rhs.numerator << " / " << rhs.denominator << ')';
//    return out;
//}

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

    if (rhs.denominator == 1)
    {
        out << rhs.numerator;
        return out;
    }

    out << '(' << rhs.numerator << " / " << rhs.denominator << ')';
    return out;
}
//
//std::istream& operator>>(std::istream& in, Fraction& rhs)
//{
//    in >> rhs.numerator;
//    in >> rhs.denominator;
//    rhs.denominator = (rhs.denominator ? rhs.denominator : 1);
//    rhs.reduce();
//    return in;
//}

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

void Fraction::reduce()
{
    int gcdVal { gcd(numerator, denominator) };
    numerator /= gcdVal;
    denominator /= gcdVal;

    if (denominator < 0 and numerator < 0)
    {
        denominator *= -1;
        numerator *= -1;
    }
}
void Fraction::print() const
{
    std::cout << '(' << numerator << " / " << denominator << ")";
};

int main()
{
    const Fraction a{ 2,16 };
    const Fraction b{ 2,4 };
    Fraction k{ 5,8 };
    int x{ 42 };
    Fraction c{4,8};


    //c = operator*(a,b);
    //c = a.operator*(b);
    /*c = a * b;
    c = a * x;*/

    std::cout << "x = " << x << '\n';


    c = a * b * k;


    std::cout << '\n';

    //c.print();

    std::cout << "Fraction a = " << a << '\n';
    std::cout << "Fraction b = " << b << '\n' << "Fraction k = " << k << '\n';
    std::cout << "Fraction c = " << c << '\n';

    std::cout << '\n';

    std::cout << "Fraction a = ";
    a.print();
    std::cout << '\n' << "Fraction b = ";
    b.print();
    std::cout << '\n' << "Fraction k = ";
    k.print();
    std::cout << '\n' << "Fraction c = ";
    c.print();
    std::cout << '\n';

    std::cout << '\n';
}