Answer to Question #195346 in C++ for Mohid butt

Question

Implement class Rational / Fraction as shown below. Add features in that class

such as

a) Create a constructor that prevents a 0 denominator in a fraction

b) Create a function to reduce or simplify fractions that are not in reduced form

c) Overload the addition (+), subtraction (-), multiplication (*) and division (/) ,

assignment operator (=), compound operators +=, -=, *=, /=, the relational operators

(<, >, <=, >=, ==, !=), unary operators such as ++ postfix, ++prefix, --postfix,--prefix, +

unary and –unary, Insertion operator << and extraction operator >> (will be

implemented as friend functions )

Class Definition is as given below; you need to implement Fraction.cpp and main

file to test the operators.in c++

Answer 1

Fraction.h File

#pragma once


#ifndef H_fraction
#define H_fraction


#include <iostream>


using namespace std;


class Fraction{
	// overload stream insertion and extraction operators
	friend ostream& operator<< (ostream&, const Fraction&);
	friend istream& operator>> (istream&, Fraction&);
public:
	//Constructor
	Fraction(int num = 0, int den = 1);
	~Fraction(void);
	//overload +
	Fraction operator+(Fraction otherFraction);
	//overload *
	Fraction operator*(Fraction otherFraction);
	//overload -
	Fraction operator-(Fraction otherFraction);
	//overload /
	Fraction operator/(Fraction otherFraction);
	


	//overload relational operators
	bool operator==(Fraction otherFraction) const;
	bool operator!=(Fraction otherFraction) const;
	bool operator<=(Fraction otherFraction) const;
	bool operator<(Fraction otherFraction) const;
	bool operator>=(Fraction otherFraction) const;
	bool operator>(Fraction otherFraction) const;   
	// operators +=, -=, *=, /=, the relational operators
	Fraction operator+=(const Fraction otherFraction);
	Fraction operator-=(const Fraction otherFraction);
	Fraction operator*=(const Fraction otherFraction);
	Fraction operator/=(const Fraction otherFraction);


	Fraction& operator++();      // Prefix
	Fraction operator++(int);     // Postfix
	Fraction& operator--();      // Prefix
	Fraction operator--(int);     // Postfix




private:
	int numerator; //variable to store the numerator
	int denominator; //variable to store the denominator
	void reduce(void);


};


#endif

Fraction.cpp File:

#include "Fraction.h"
#include <iostream>
#include "Fraction.h"


using namespace std;






Fraction::~Fraction(void)
{
}




// overload operator <<
ostream& operator << (ostream& os, const Fraction& fraction)
{
	if(fraction.numerator ==fraction.denominator){
		os <<"1";
	}else{
		os << fraction.numerator << '/' << fraction.denominator;
	}
	
    return os;
}


// overload operator >>
istream& operator>> (istream& is, Fraction& fraction)
{
	int newNumerator;
    int newDenominator = 1;
	bool isCorrect=false;
	while(!isCorrect){
		is >> newNumerator;
		char value;
		is.get(value);
		if(!is.eof()){
			if(value == '/' ){
				is >> newDenominator;
				isCorrect=true;
			}else{
				is.putback(value);
				is.clear();
				is.ignore();
			}
		}
	}


    fraction = Fraction(newNumerator,newDenominator);
    return is;
}


// overload operator ==
bool Fraction::operator==(Fraction otherFraction) const
{
	  return (numerator == otherFraction.numerator &&
		  denominator == otherFraction.denominator);
}


// overload operator !=
bool Fraction::operator!=(Fraction otherFraction) const
{
	return !(*this == otherFraction);
}


// overload operator <=
bool Fraction::operator<=(Fraction otherFraction) const
{
	int fraction1NumeratorResult =this->numerator * otherFraction.denominator;
	int Fraction2NumeratorResult = otherFraction.numerator * this->denominator;
	return (fraction1NumeratorResult<=Fraction2NumeratorResult);
}


// overload operator <
bool Fraction::operator<(Fraction otherFraction) const
{
	return !(*this <= otherFraction) || !(*this >= otherFraction);
}


// overload operator >=
bool Fraction::operator>=(Fraction otherFraction) const
{
	return ((*this > otherFraction && *this == otherFraction) || (*this > otherFraction || *this == otherFraction));
}


// overload operator >
bool Fraction::operator>(Fraction otherFraction) const
{
	return !(*this <= otherFraction);
}


// constructor
Fraction::Fraction(int num, int deno)
{
	this->numerator = num;
	if (deno == 0)
	{
		cout << "Denominator cannot be zero" << endl;
		this->denominator = 1;
	}
	else{
		this->denominator = deno;
	}
}


// overload the operator +
Fraction Fraction::operator+(Fraction otherFraction)
{
	Fraction sumFraction;
	sumFraction.numerator = numerator * otherFraction.denominator + denominator * otherFraction.numerator;
	sumFraction.denominator = denominator * otherFraction.denominator;
	sumFraction.reduce();
	return sumFraction;
}


// overload the operator *
Fraction Fraction::operator*(Fraction otherFraction)
{
	Fraction multiplyFraction;
	multiplyFraction.numerator = numerator * otherFraction.numerator;
	multiplyFraction.denominator = denominator * otherFraction.denominator;
	multiplyFraction.reduce();
	return multiplyFraction;
}


// overload operator -
Fraction Fraction::operator-(Fraction otherFraction)
{
	Fraction subtractFraction;
	subtractFraction.numerator = numerator * otherFraction.denominator - denominator * otherFraction.numerator;
	subtractFraction.denominator = denominator * otherFraction.denominator;
	subtractFraction.reduce();
	return subtractFraction;
}


// overload operator /
Fraction Fraction::operator/(Fraction otherFraction)
{
	Fraction divideFraction;
	if (otherFraction.numerator == 0)
	{
		cout << "Cannot divide by zero" << endl;
	}
	else
	{
		divideFraction.numerator = numerator * otherFraction.denominator;
		divideFraction.denominator = denominator * otherFraction.numerator;
		divideFraction.reduce();
	}
	return divideFraction;
}


Fraction Fraction::operator+=(const Fraction otherFraction){
	return ((*this)+otherFraction);
}
Fraction Fraction::operator-=(const Fraction otherFraction){
	return ((*this)-otherFraction);
}
Fraction Fraction::operator*=(const Fraction otherFraction){
	return ((*this)*otherFraction);
}
Fraction Fraction::operator/=(const Fraction otherFraction){
	return ((*this)/otherFraction);
}


// Prefix
Fraction& Fraction::operator++(){
   this->numerator++;
   this->denominator++;
   return *this;
} 
// Postfix
Fraction Fraction::operator++(int){
   Fraction temp = *this;
   ++*this;
   return temp;
}
// Prefix
Fraction& Fraction::operator--(){
   this->numerator--;
   this->denominator--;
   return *this;
} 
// Postfix
Fraction Fraction::operator--(int){
  Fraction temp = *this;
   --*this;
   return temp;
}


void Fraction::reduce(void)
{
	int gcd = 1;
	int largest = (numerator > denominator) ? numerator: denominator;	
	for (int i = 1; i < largest; ++i){
		if ( numerator % i == 0 && denominator % i == 0){
			gcd = i;
		}
	}
	numerator /= gcd;
	denominator /= gcd;
}

main.cpp file:

#include <iostream>
#include <iomanip>
#include "Fraction.h"


using namespace std;


int main()
{
	Fraction fraction1(5, 6);
	Fraction fraction2;
	Fraction fraction3;


	cout << fixed;
	cout << showpoint;
	cout << setprecision(2);


	cout << "fraction1 = " << fraction1 << endl;
	cout << "fraction2 = " << fraction2 << endl;


	cout << "Enter the fraction in the form a/b: ";
	cin >> fraction2;
	cout << endl;


	cout << "New value of fraction2 = " << fraction2 << endl;


	fraction3 = fraction1 + fraction2;


	cout << "fraction3 = " << fraction3 << endl;
	cout << fraction1 << " + " << fraction2 << " = " << fraction1 + fraction2 << endl;
	cout << fraction1 << " * " << fraction2 << " = " << fraction1 * fraction2 << endl;


	fraction3 = fraction1 - fraction2;


	cout << "fraction3 = " << fraction3 << endl;
	cout << fraction1 << " - " << fraction2 << " = " << fraction1 - fraction2 << endl;
	cout << "(" << fraction1 << ") / (" << fraction2 << ") = " << fraction1 / fraction2 << endl;


	fraction3++;
	cout << "fraction3 ++ = " << fraction3 << endl;


	fraction3--;
	cout << "fraction3 -- = " << fraction3 << endl;


	cout << "fraction3 >= fraction1: " << (fraction3>=fraction1) << endl;
	cout << "fraction3 < fraction1: " << (fraction3<fraction1) << endl;




	cout << "fraction3+=fraction1: " << (fraction3+=fraction1) << endl;
	cout << "fraction3-=fraction1: " << (fraction3-=fraction1) << endl;
	cout << "fraction3*=fraction1: " << (fraction3*=fraction1) << endl;
	cout << "fraction3/=fraction1: " << (fraction3/=fraction1) << endl;
	


	system("pause");
	return 0;
}