Question

0 Input: Output: Value: Under control of main function Under control of main function The purpose of this assignment is to become familiar with the process of providing overloaded operators for a class. The Rational class from Labs 02, 03, and 05 will be modified to provide overloaded operators for performing arithmetic on Rational numbers an overloaded unary minus for negating a Rational number (previously implemented as the additive an overloaded assignment operator for assigning one Rational number to another (this is necessary since the private data includes an array overloaded operators for the equality operators and the relational operators, and overloaded input and output operators to facilitate the input and output of Rational numbers. A header file is shown in Figure 1, a sample main function for testing your implementation is shown in Figure 2, and a sample execution sequence is shown in Figure 3. To use the Makefile as distributed in class, add a target of lab07 to targets2srcfileswithlibrary. 1 #ifndef LAB07H - 2 #define LAB07-H #include <iostream> using namespace std s class Rational 10 Ioverloaded input operator initializes Rational rat from input stream in 1 friend istreamk operator>> (istreank in, Rational& rat); 12 overloaded output operator prints Rational rat to output stream out 13 friend ostre㏂& operator<s(08treank out, const Rational& rat); 14 public: RationalO: // default conatructor // additional constructor 1 Rational (int num, int denom) 17 void setNumerator (int num); 1void setDenominator (int denom) 19 int getNumerator) const; // set denominator to denom // returns numerator // returns denominator /I reduce to lovest terms I and normalize // returns multiplicative int getDenominator const void reduce Rational multiplicativeInverseO conat; inverse of this a Rational& operator-(conat Rationalk rha); Rational operator+(const Rationalk addend) const;// returns thisaddend Rational operator- conat; Rational operator-(const Rationalk subtrahend) const;// returns *this subtrahend // returns (this) 30 Rational operator (const Rationalk multiplicand) conat;// returns *this multiplicand Rational operator/(const Rationalk divisor) const;// returns *this divisor Figure 1. /usr/local/2336/include/1ab07.h (Part 1 of 2) CS 2336Data Structures and Algorithms Page 1

This is my process, can you fix it for me?

Answer 1

lab07.h
#ifndef LAB07_H
#define LAB07_H

#include <iostream>

using namespace std;

class Rational
{
// overloaded input operator initializes Rational rat from input stream in
friend istream& operator>>(istream& in, Rational& rat);

// overloaded output operator prints Rational rat to output stream out
friend ostream& operator<<(ostream& out, const Rational& rat);
public:
Rational();                                     // default constructor
Rational(int num, int denom);                   // additional constructor
void setNumerator(int num);                     // set numerator to num
void setDenominator(int denom);                 // set denominator to denom
int getNumerator() const;                       // returns numerator
int getDenominator() const;                     // returns denominator

void reduce();                                  // reduce to lowest terms
                                                  //   and normalize
Rational multiplicativeInverse() const;         // returns multiplicative
                                                  //   inverse of *this

Rational& operator=(const Rational& rhs);       // *this = rhs;
Rational operator+(const Rational& addend) const;// returns *this + addend
Rational operator-() const;                     // returns -(*this)
Rational operator-(const Rational& subtrahend) const;// returns *this - subtrahend
Rational operator*(const Rational& multiplicand) const;// returns *this * multiplicand
Rational operator/(const Rational& divisor) const;// returns *this / divisor

bool operator==(const Rational& rhs) const;     // *this == rhs
bool operator!=(const Rational& rhs) const;     // *this != rhs
bool operator< (const Rational& rhs) const;     // *this < rhs
bool operator<=(const Rational& rhs) const;     // *this <= rhs
bool operator> (const Rational& rhs) const;     // *this > rhs
bool operator>=(const Rational& rhs) const;     // *this >= rhs

private:
int r[2];                                       // r[0] represents numerator
                                                  // r[1] represents denominator
int gcd(int m, int n) const;                    // returns the greatest
                                                  //   common divisor of m
                                                  //   and n
int lcm(int m, int n) const;                    // returns the least common
                                                  //   multiple of m and n
};

#endif

lab07.cpp

#include <lab07.h>
#include <stdlib.h>

// overloaded input operator initializes Rational rat from input stream in
//to istream& operator>>(istream in, rational rat)
//istream Rational::read

// overloaded output operator prints Rational rat to output stream out
ostream& operator<<(ostream& out, const Rational& rat)
{
   out << rat.getNumerator() << '/' << rat.getDenominator();

   return out;
}

istream& operator>>(istream& in, Rational& rat)                    // Read Rational from input stream
{
   int num, denom;
  
   in >> num >> denom;
   rat.setNumerator(num);
   rat.setDenominator(denom);
  
   return in;
}

Rational& Rational::operator=(const Rational& rhs)                             // *this = rhs;
{
   if(this != &rhs)
   {
       this->setNumerator(rhs.getNumerator());
       this->setDenominator(rhs.getDenominator());
   }

  
   return *this;
}


Rational Rational::operator+(const Rational& addend) const                   // returns *this + addend
{
   Rational sum;    // declare a local rational object
   int lcm = this->lcm(this->getDenominator(), addend.getDenominator());
  
   sum.setNumerator(lcm * this->getNumerator() / this->getDenominator() +
                   lcm * addend.getNumerator() / addend.getDenominator());
   sum.setDenominator(lcm);
   sum.reduce();
  
   return sum;
                      
}



Rational Rational::operator-() const                                       // returns -(*this)
{
   return Rational(-1 * this->getNumerator(), this->getDenominator());
}



Rational Rational::operator-(const Rational& subtrahend) const                   // returns *this - subtrahend
{
   //return this->add(subtrahend.additiveInverse());
   //return this->operator+(subtrahend.operator-()); // works
   return *this + -subtrahend;
  
}

Rational Rational::operator*(const Rational& multiplicand) const               // returns *this * multiplicand
{
      Rational product;                   // declare a local rational object

      product.setNumerator(this->getNumerator() * multiplicand.getNumerator());
      product.setDenominator(this->getDenominator() * multiplicand.getDenominator());

      product.reduce();
      return product;
}

Rational Rational::operator/(const Rational& divisor) const // returns *this
{

   return this->operator*(divisor.multiplicativeInverse());
}

bool Rational::operator==(const Rational& rhs) const     // *this == rhs
{
   return (*this - rhs).getNumerator() == 0;
}


bool Rational::operator!=(const Rational& rhs) const     // *this != rhs
{
   return !(*this == rhs);
   return *this != rhs;
}

bool Rational::operator< (const Rational& rhs) const     // *this < rhs
{
   if((this->getNumerator() * rhs.getDenominator()) < (rhs.getNumerator() * this->getDenominator()))
   {
       return 1;
   }
   else
   {
       return 0;
   }
}


bool Rational::operator<=(const Rational& rhs) const     // *this <= rhs
{
   return (*this < rhs || *this == rhs);
}

bool Rational::operator>(const Rational& rhs) const     // *this > rhs
{
  
   return !(*this < rhs);
}
bool Rational::operator>=(const Rational& rhs) const     // *this >= rhs
{
   return (!(*this < rhs) || *this == rhs);
  
}

lab07main.C

#include <lab07.h>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
Rational first(1, -2), second(-3, 0), result;

cout << boolalpha;
cout << "first = " << first << " second = " << second
       << " result = " << result << endl;

while (cin >> first >> second)
{
    cout << "first = " << first;
    result = -first;
    result.reduce();
    cout << " -first = " << result << endl;

    cout << first << " + " << second << " = " << first + second << endl;
    cout << first << " - " << second << " = " << first - second << endl;
    cout << first << " * " << second << " = " << first * second << endl;
    cout << first << " / " << second << " = " << first / second << endl;

    cout << first << " == " << second << " = " << (first == second) << endl;
    cout << first << " != " << second << " = " << (first != second) << endl;
    cout << first << " < " << second << " = " << (first < second) << endl;
    cout << first << " <= " << second << " = " << (first <= second) << endl;
    cout << first << " > " << second << " = " << (first > second) << endl;
    cout << first << " >= " << second << " = " << (first >= second) << endl;
}

return EXIT_SUCCESS;
}