Lab 5 - Fractions

// -------- Rational.h ----------

#include <iostream>
using namespace std;

#pragma once
class Rational
{
    friend Rational operator+(int num, const Rational& rightRational);
    friend Rational operator-(int num, const Rational& rightRational);
    friend Rational operator*(int num, const Rational& rightRational);
    friend Rational operator/(int num, const Rational& rightRational);

public:
    Rational(int = 0, int = 1);

    void set_numerator(int numerator);
    void set_denominator(int denominator);

    int get_numerator() const { return this->_numerator; }
    int get_denominator() const { return this->_denominator; }

    void print_rational() const;

    Rational operator+(const Rational& rightRational);
    Rational operator-(const Rational& rightRational);
    Rational operator*(const Rational& rightRational);
    Rational operator/(const Rational& rightRational);

    void reverse();

private:
    int _numerator;
    int _denominator;

    void reduce();
    int getGCD(int iX, int iY);
    void keep_positive();
};


ostream& operator<<(ostream& out, const Rational& rightRational);
istream& operator>>(istream& in, Rational& rightRational);






// -------- Rational.cpp ----------


#include "Rational.h"

Rational::Rational(int numerator, int denominator)
{
    set_numerator(numerator);
    set_denominator(denominator);
    reduce();
}

void Rational::set_denominator(int denominator)
{
    if (denominator == 0)
    {
        cout << endl << "Denominator cannot be 0. setting to 1." << endl;
        denominator = 1;
    }

    this->_denominator = denominator;
}

void Rational::set_numerator(int numerator)
{
    this->_numerator = numerator;
}

int Rational::getGCD(int iX, int iY)
{
    iX = abs(iX);
    iY = abs(iY);

    while (iX * iY != 0)
    {
        if (iX > iY)
        {
            iX %= iY;
        }

        else
        {
            iY %= iX;
        }
    }

    return iX != 0 ? iX : iY;
}

void Rational::reduce()
{
    int gcd = getGCD(this->get_numerator(), this->get_denominator());

    this->_numerator /= gcd;
    this->_denominator /= gcd;

    keep_positive();
}

void Rational::print_rational() const
{
    cout << endl << get_numerator() << " / " << get_denominator() << endl;
}

void Rational::keep_positive()
{
    if (this->_numerator * this->_denominator > 0) // positive
    {
        this->_numerator = abs(this->_numerator);
        this->_denominator = abs(this->_denominator);
    }
}

// Operator Overloading

Rational Rational::operator+(const Rational& rightRational)
{
    Rational temp;

    temp.set_denominator(this->get_denominator() * rightRational.get_denominator());
    temp.set_numerator((this->get_numerator() * rightRational.get_denominator()) + (this->get_denominator() * rightRational.get_numerator()));

    temp.reduce();

    return temp;
}


Rational Rational::operator-(const Rational& rightRational)
{
    Rational temp;

    temp.set_denominator(this->get_denominator() * rightRational.get_denominator());
    temp.set_numerator((this->get_numerator() * rightRational.get_denominator()) - (this->get_denominator() * rightRational.get_numerator()));

    temp.reduce();

    return temp;
}


Rational Rational::operator*(const Rational& rightRational)
{
    Rational temp;

    temp.set_numerator(this->get_numerator() * rightRational.get_numerator());
    temp.set_denominator(this->get_denominator() * rightRational.get_denominator());

    temp.reduce();

    return temp;
}

Rational Rational::operator/(const Rational& rightRational)
{
    Rational temp;

    temp.set_numerator(this->get_numerator() * rightRational.get_denominator());
    temp.set_denominator(this->get_denominator() * rightRational.get_numerator());

    temp.reduce();

    return temp;
}

// cout
ostream& operator<<(ostream& out, const Rational rightRational)
{
    if (rightRational.get_numerator() * rightRational.get_denominator() < 0) // negative
        out << endl << "-(" << abs(rightRational.get_numerator()) << " / " << abs(rightRational.get_denominator()) << ")" << endl;

    else if (rightRational.get_numerator() * rightRational.get_denominator() > 0)
        out << endl << rightRational.get_numerator() << " / " << rightRational.get_denominator() << endl;

    else if (rightRational.get_numerator() == 0)
        out << endl << "0" << endl;

    return out;
}


istream& operator>>(istream& in, Rational& rightRational)
{
    int numerator, denominator;
    cout << "Enter numerator: ";
    in >> numerator;

    cout << "Enter denominator: ";
    in >> denominator;

    rightRational.set_numerator(numerator);
    rightRational.set_denominator(denominator);

    return in;
}




// Friend - Operator Overloading

Rational operator+(int num, const Rational& rightRational)
{
    Rational temp(num, 1);

    return temp + rightRational;

}

Rational operator-(int num, const Rational& rightRational)
{
    Rational temp(num, 1);

    return temp - rightRational;

}

Rational operator*(int num, const Rational& rightRational)
{
    Rational temp(num, 1);

    return temp * rightRational;
}

Rational operator/(int num, const Rational& rightRational)
{
    Rational temp(num, 1);

    return temp / rightRational;

}




void Rational::reverse()
{
    Rational temp(1, 1);

    *this = temp / *this;

}



// -------- Source.cpp ----------


#include <iostream>
using namespace std;
#include "Rational.h"

int main()
{
    Rational r1(-1,2);
    Rational r2(-3, -4);

    cout << r1 << r2;

    Rational r3 = r1 + r2;
    cout << r3;
}