write the To Do's to get the exact output:

NOte: A valid Fraction number has a non-negative numerator and a positive denominator. Default constructor initializes the object to safe empty state (an object with denom equals -1). The two-argument constructor also validates the parameters and sets the object to the safe empty state if the parameters are not valid.

Write the definitions and prototypes of following functions in Fraction.cpp and Fraction.h respectively (They are indicated in the files by //TODO tag):

Define isEmpty function as a member function, which returns true if the object is in safe empty state (an object is in the safe empty state if denominator (denom) equals -1).

Define display function, which sends a Fraction number to the output stream (with the Numerator/denominator format). This function just prints "Invalid Fraction Object!" in the screen if the object is in the safe empty state. In case that object denominator equals 1, it just print the numerator.

Define the operator functions for the following operators:

+=, +, *

The overload of the above operators should make the following code possible:

The member operator+ : Adds two Fraction numbers and returns a Fraction number as the result. This function returns an object with the safe empty state if either of Fraction numbers (operands) is in safe empty state. It makes following code possible:

A+B ( where A and B are Fraction objects)

The member operator+= : Adds two Fraction numbers and assigns the result to the left operand, then returns a reference to the left operand. If either of Fraction numbers (operands) is in safe empty state, it initializes the left operand to the safe empty state, then returns a reference to the left operand. It makes following code possible:

A+=B ( where A and B are Fraction objects)

The member operator* : Multiplies two Fraction numbers and returns a Fraction number as the result. This function returns an object with the safe empty state if either of Fraction numbers (operands) is in safe empty state. It makes following code possible:

A*B ( where A and B are Fraction objects)

fraction.cpp

#include "Fraction.h"

using namespace std;

namespace sict{ Fraction::Fraction(){ denom =-1; // safe empty state } Fraction::Fraction(int n, int d) // n: numerator, d: denominator { if(n >= 0 && d > 0){ num = n; denom = d; reduce(); } else denom =-1; // set to safe empty state }

int Fraction::gcd() // returns the greatest common divisor of num and denom { int mn = min(); // min of num and denom int mx = max(); // mX of num and denom

for (int x=mn ; x > 0 ; x--) // find the greatest common divisor if( mx % x == 0 && mn % x == 0) return x; return 1;

}

void Fraction::reduce() // simplify the Fraction number { int tmp = gcd(); num /= tmp; denom /= tmp; }

int Fraction::max () { return (num >= denom) ? num : denom; }

int Fraction::min() { return (num >= denom) ? denom : num; }

// in_lab

// TODO: write the implementation of display function HERE

// TODO: write the implementation of isEmpty function HERE

// TODO: write the implementation of member operator+= function HERE

// TODO: write the implementation of member operator+ function HERE

// TODO: write the implementation of member operator* function HERE

}

fraction.h

#ifndef SICT_Fraction_H__ #define SICT_Fraction_H__

#include

using namespace std;

namespace sict{ class Fraction{ private:

int num; // Numerator int denom; // Denominator

int gcd(); // returns the greatest common divisor of num and denom

int max(); // returns the maximum of num and denom int min(); // returns the minimum of num and denom public:

void reduce(); // simplifies a Fraction number by dividing the // numerator and denominator to their greatest common divisor

Fraction(); // default constructor Fraction(int n , int d=1); // construct n/d as a Fraction number

void display() const;

bool isEmpty() const; // member operator functions

// TODO: write the prototype of member operator+= function HERE

// TODO: write the prototype of member operator+ function HERE

// TODO: write the prototype of member operator* function HERE

}; }; #endif

main.cpp

include

#include "Fraction.h"

using namespace sict;

using namespace std;

int main(){

cout << "------------------------------" << endl;

cout << "Fraction Class Operators Test:" << endl;

cout << "------------------------------" << endl;

Fraction A;

cout << "Fraction A; // ";

cout << "A = ";

A.display();

cout << endl;

Fraction B(1, 3);

cout << "Fraction B(1, 3); // ";

cout << "B = ";

B.display();

cout << endl;

Fraction C(-5, 15);

cout << "Fraction C(-5, 15); //";

cout << " C = " ;

C.display();

cout << endl;

Fraction D(2, 4);

cout << "Fraction D(2, 4); //";

cout << " D = ";

D.display();

cout << endl;

Fraction E(8, 4);

cout << "Fraction E(8, 4); //";

cout << " E = " ;

E.display();

cout << endl;

cout << endl;

cout << "A+B equals ";

(A+B).display();

cout << endl;

cout << "B+3 equals ";

(B+3).display();

cout << endl;

cout << "B+D equals ";

(B+D).display();

cout << endl;

cout << "(A = D = (B+=E)) equals " ;

(A = D = (B+=E)).display();

cout << endl;

cout << "Now A, D, B, and E equal " ;

A.display();

cout << ", " ;

D.display();

cout << ", ";

B.display();

cout << ", ";

E.display();

cout << endl;

return 0;

}

Output Example: (Your output should exactly match the following)

------------------------------

Fraction Class Operators Test:

------------------------------

Fraction A; // A = Invalid Fraction Object!

Fraction B(1, 3); // B = 1/3

Fraction C(-5, 15); // C = Invalid Fraction Object!

Fraction D(2, 4); // D = 1/2

Fraction E(8, 4); // E = 2

A+B equals Invalid Fraction Object!

B+3 equals 10/3

B+D equals 5/6

(A = D = (B+=E)) equals 7/3 Now A, D, B, and E equal 7/3, 7/3, 7/3, 2