PV913FractionIncDecInput

#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);

    //fractions[1] = Fraction{ 15,16 };
    //Fraction& operator=(const Fraction& rhs);

    //ClassName& operator=(const ClassName& rhs);

    Fraction& operator=(const int rhs);

    operator int() const { return numerator / denominator; };
    operator float() const { return (float)numerator / (float)denominator; };
    Fraction& operator+=(int rhs) { numerator += rhs * denominator; return *this; };
    Fraction& operator-=(int rhs) { numerator -= rhs * denominator; return *this; };

    Fraction& operator++() { numerator += denominator; return *this; };
    Fraction& operator--() { numerator -= denominator; return *this; };
    Fraction operator++(int)
    {
        Fraction old{ *this };

        //numerator += denominator;
        ++(*this);

        return old;
    }

    Fraction operator--(int)
    {
        Fraction old{ *this };

        //numerator -= denominator;
        --(*this);

        return old;
    }

};


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

/*Fraction& Fraction::operator=(const Fraction& rhs)
{
    std::cout << "Fraction " << this << " assigned by Fraction" << &rhs << '\n';
    this->numerator = rhs.numerator;
    this->denominator = rhs.denominator;
    return *this;
}
*/

Fraction& Fraction::operator=(const int rhs)
{
    std::cout << "Fraction " << this << " assigned by Int" << &rhs << '\n';
    this->numerator = rhs;
    this->denominator = 1;
    return *this;
}

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::istream& operator>>(std::istream& in, Fraction& rhs)
{
    in >> rhs.numerator;
    in >> rhs.denominator;
    rhs.denominator = (rhs.denominator ? rhs.denominator : 1);
    rhs.reduce();
    return in;
}

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{ 36,16 };
      const Fraction b{ 2,4 };
      Fraction k{ 5,8 };
      int ival{ 42 };
      float fval{};
      Fraction c{ 4,8 };

      ival = a;

      fval = k++;

      std::cout << "ival = " << ival << " fval= " << fval << '\n';
      std::cout << "k = " << k << '\n';

      return 0;
    //int a{ 35 };

    //const int fractionsSize{ 3 };
    //Fraction fractions[fractionsSize]{};//{ {1,2}, {3,4}, {5,6}, {7,8}, {9,10} };
    //fractions[1] = Fraction{ 15,16 };
    //(fractions[2] = a) = Fraction{ 2,3 };
    //for (int i{}; i < fractionsSize; ++i)
    //{
    //    std::cout << "Fraction #" << i << ' ' << fractions[i] << '\n';
    //}

    //return 0;

    //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';
        */
}