Please write an operator overloading version for rational number. 1. The templat
ID: 3553577 • Letter: P
Question
Please write an operator overloading version for rational number.
1. The template for class definition will be:
class RationalNumber
{
public:
RationalNumber( int = 0, int = 1 ); // default constructor
/* Write prototype for operator + */
/* Write prototype for operator - */
/* Write prototype for operator * */
/* Write prototype for operator / */
void printRational() const; // display rational number
private:
int numerator; // private variable numerator
int denominator; // private variable denominator
void reduction(); // function for fraction reduction
}; // end class RationalNumber
2. The following is the code for the main function to test your program.
int main()
{
RationalNumber c( 7, 3 ), d( 3, 9 ), x;
c.printRational();
cout << " + ";
d.printRational();
cout << " = ";
x = c + d; // test overloaded operators + and =
x.printRational();
cout << ' ';
c.printRational();
cout << " - ";
d.printRational();
cout << " = ";
x = c - d; // test overloaded operators - and =
x.printRational();
cout << ' ';
c.printRational();
cout << " * ";
d.printRational();
cout << " = ";
x = c * d; // test overloaded operators * and =
x.printRational();
cout << ' ';
c.printRational();
cout << " / ";
d.printRational();
cout << " = ";
x = c / d; // test overloaded operators / and =
x.printRational();
cout << ' ';
c.printRational();
cout << " is: ";
return 0;
} // end main
Explanation / Answer
If you need I can give you prewritten detailed solution to this question
Its liitle big
#ifndef __FRACTION_HXX // Control inclusion of header files
#define __FRACTION_HXX
/************ C++ Headers ************************************/
#include <iostream> // Defines istream & ostream for IO
using namespace std;
/************ CLASS Declaration ******************************/
class Fraction {
public:
// CONSTRUCTORS
// ------------
Fraction(int = 1, int = 1); // Uses default parameters. Overloads to
// Fraction(int, int);
// Fraction(int);
// Fraction();
// Constructor for explicit Conversion
explicit Fraction(double); // explicit double to Fraction conversion
// Copy Constructor
Fraction(const Fraction&); // Param cannot be changed (const)
// DESTRUCTOR
// ----------
~Fraction(); // No virtual destructor needed
// BASIC ASSIGNEMENT OPERATOR
// --------------------------
Fraction& operator=(const Fraction&);
// UNARY ARITHMETIC OPERATORS
// --------------------------
Fraction operator-(); // Operand 'this' implicit
Fraction operator+();
Fraction& operator--(); // Pre-decrement. Dividendo. p/q <-- p/q - 1
Fraction& operator++(); // Pre-increment. Componendo. p/q <-- p/q + 1
Fraction operator--(int); // Post-decrement. Lazy Dividendo. p/q <-- p/q - 1. Returns old p/q
Fraction operator++(int); // Post-increment. Lazy Componendo. p/q <-- p/q + 1. Returns old p/q
// BINARY ARITHMETIC OPERATORS USING FRIEND FUNCTIONS
// --------------------------------------------------
friend Fraction operator+(const Fraction&, const Fraction&);
friend Fraction operator-(const Fraction&, const Fraction&);
friend Fraction operator*(const Fraction&, const Fraction&);
friend Fraction operator/(const Fraction&, const Fraction&);
friend Fraction operator%(const Fraction&, const Fraction&);
// BINARY RELATIONAL OPERATORS
// ---------------------------
bool operator==(const Fraction&);
bool operator!=(const Fraction&);
bool operator<(const Fraction&);
bool operator<=(const Fraction&);
bool operator>(const Fraction&);
bool operator>=(const Fraction&);
// ADVANCED ASSIGNEMENT OPERATORS
// ------------------------------
Fraction& operator+=(const Fraction&);
Fraction& operator-=(const Fraction&);
Fraction& operator*=(const Fraction&);
Fraction& operator/=(const Fraction&);
Fraction& operator%=(const Fraction&);
// SPECIAL OPERATORS
// -----------------
Fraction operator!(); // Inverts a fraction. !(p/q) = q/p
// BASIC I/O using FRIEND FUNCTIONS
// --------------------------------
friend ostream& operator<<(ostream&, const Fraction&);
friend istream& operator>>(istream&, Fraction&);
// CONSTANTS OF DATATYPE
// ---------------------
static const Fraction sc_fUnity; // Defines 1/1
static const Fraction sc_fZero; // Defines 0/1
// STATIC UTILITY FUNCTIONS
// ------------------------
static const int precision() { return 1000000; };
static int gcd(int, int); // Finds the gcd for two +ve integers
static int lcm(int, int); // Finds the lcm for two +ve integers
protected:
// COMPONENT FUNCTIONS
//--------------------
int GetNumerator() { return iNumerator_; }
unsigned int GetDenominator() { return uiDenominator_; }
private:
// DATA MEMBERS
// ------------
int iNumerator_; // The Numerator
unsigned int uiDenominator_; // The Denominator
// OTHER METHOD MEMBERS
// --------------------
Fraction& Normalize(); // Normalizes a fraction
};
#include "Fraction.inl" // Methods are implemented here
#endif // __FRACTION_HXX
#ifndef __FRACTION_INL // Control inclusion of header files
#define __FRACTION_INL
const Fraction Fraction::sc_fUnity(1,1);
const Fraction Fraction::sc_fZero(0,1);
Fraction& Fraction::Normalize() //this function will make sure that gcd(numerator,denomiator)=1
{
int g;
if((*this).iNumerator_==0)
{
(*this).uiDenominator_=1; //if numberator is 0 then its denomiator will only be 1
return *this;
}
else if((*this).iNumerator_<0)
{
g=(*this).gcd(-1*(*this).iNumerator_,(*this).uiDenominator_); //as we want to calculate gcd of two positive numbers
(*this).iNumerator_=-1*((-1*(*this).iNumerator_)/g);
}
else
{
g=(*this).gcd((*this).iNumerator_,(*this).uiDenominator_);
(*this).iNumerator_=(*this).iNumerator_/g;
}
(*this).uiDenominator_=(*this).uiDenominator_/g;
return *this;
}
//constructor
Fraction::Fraction(int num, int den):iNumerator_(num),uiDenominator_(den)
{
(*this).Normalize();
};
//explicit constructor
Fraction::Fraction(double temp)
{
int den=1,g,sign;
while(den<1000000)
{
if((int)temp==temp)
break;
else
{
temp*=10;
den=den*10;
}
}
iNumerator_=temp;
uiDenominator_=den;
(*this).Normalize();
};
Fraction::Fraction(const Fraction& temp) //copy constructor
{
(*this).iNumerator_=temp.iNumerator_;
(*this).uiDenominator_=temp.uiDenominator_;
};
//destructor
Fraction::~Fraction()
{
//Destructor has been called
};
Fraction& Fraction::operator=(const Fraction &temp)
{
(*this).iNumerator_=temp.iNumerator_;
(*this).uiDenominator_=temp.uiDenominator_;
return *this;
};
Fraction Fraction::operator-()
{
Fraction temp=*this;
temp.iNumerator_*=-1;
return temp;
};
//operator + will produce no effect on the fraction
Fraction Fraction::operator+()
{
Fraction temp=*this;
temp.iNumerator_*=1;
return temp;
};
Fraction& Fraction::operator--() // Pre-decrement. Dividendo. p/q <-- p/q - 1
{
this->iNumerator_=((*this).iNumerator_)-((*this).uiDenominator_);
return *this;
};
Fraction& Fraction::operator++() // Pre-increment. Componendo. p/q <-- p/q + 1
{
(*this).iNumerator_=((*this).iNumerator_)+((*this).uiDenominator_);
return *this;
};
Fraction Fraction::operator--(int) // Post-decrement. Lazy Dividendo. p/q <-- p/q - 1. Returns old p/q
{
Fraction temp=(*this);
this->iNumerator_=((*this).iNumerator_)-((*this).uiDenominator_);
return temp;
};
Fraction Fraction::operator++(int)
{
Fraction temp=(*this);
this->iNumerator_=((*this).iNumerator_)+((*this).uiDenominator_);
return temp;
};
int Fraction::gcd(int a, int b) // Finds the gcd for two +ve integers
{
int i,g=1;
for(i=1;i<=a;i++)
if(a%i==0&&b%i==0)
g=i;
return g;
};
int Fraction::lcm(int a, int b) // Finds the lcm for two +ve integers
{
int g=gcd(a,b); //as gcd*lcm=a*b;
return (a*b)/g;
};
Fraction operator+(const Fraction& temp1, const Fraction& temp2)
{
Fraction temp;
int g;
temp.iNumerator_=(temp1.iNumerator_*temp2.uiDenominator_)+(temp2.iNumerator_*temp1.uiDenominator_);
temp.uiDenominator_=temp1.uiDenominator_*temp2.uiDenominator_;
temp.Normalize();
return temp;
};
Fraction operator-(const Fraction& temp1, const Fraction& temp2)
{
Fraction temp_1=temp1;
Fraction temp_2=temp2;
Fraction temp;
temp=temp_1+(-temp_2); //making use of porperty of addition
temp.Normalize();
return temp;
};
Fraction operator*(const Fraction& temp1, const Fraction& temp2)
{
Fraction temp;
int g;
temp.iNumerator_=(temp1.iNumerator_)*(temp2.iNumerator_);
temp.uiDenominator_=temp1.uiDenominator_*temp2.uiDenominator_;
temp.Normalize();
return temp;
};
Fraction operator/(const Fraction& temp1, const Fraction& temp2)
{
Fraction temp,temp3;
int g;
temp=temp2;
temp=(!temp)*temp1; //making use of property of inversion
temp.Normalize();
return temp;
};
Fraction operator%(const Fraction& temp1, const Fraction& temp2)
{
//finding the remainder
Fraction temp;
int d;
temp=temp1/temp2;
d=temp.iNumerator_/temp.uiDenominator_;
temp=temp1-(d*temp2);
temp.Normalize();
return temp;
};
//DECISION MAKING OPERATORS WHICH RETURN BOOLEAN
bool Fraction::operator==(const Fraction& temp)
{
if(((*this).iNumerator_==temp.iNumerator_)&&((*this).uiDenominator_==temp.uiDenominator_))
return true;
else
return false;
};
bool Fraction::operator!=(const Fraction& temp)
{
if(((*this).iNumerator_==temp.iNumerator_)&&((*this).uiDenominator_==temp.uiDenominator_))
return false;
else
return true;
};
bool Fraction::operator<(const Fraction& temp)
{
float num1,num2;
num1=((*this).iNumerator_)*1.0/((*this).uiDenominator_);
num2=((temp).iNumerator_)*1.0/((temp).uiDenominator_);
if(num1<num2)
return true;
else
return false;
};
bool Fraction::operator<=(const Fraction& temp)
{
float num1,num2;
num1=((*this).iNumerator_)*1.0/((*this).uiDenominator_);
num2=((temp).iNumerator_)*1.0/((temp).uiDenominator_);
if(num1>num2)
return false;
else
return true;
};
bool Fraction::operator>(const Fraction& temp)
{
float num1,num2;
num1=((*this).iNumerator_)*1.0/((*this).uiDenominator_);
num2=((temp).iNumerator_)*1.0/((temp).uiDenominator_);
if(num1>num2)
return true;
else
return false;
};
bool Fraction::operator>=(const Fraction& temp)
{
float num1,num2;
num1=((*this).iNumerator_)*1.0/((*this).uiDenominator_);
num2=((temp).iNumerator_)*1.0/((temp).uiDenominator_);
if(num1<num2)
return false;
else
return true;
};
// ADVANCED ASSIGNEMENT OPERATORS
// ------------------------------
Fraction& Fraction::operator+=(const Fraction& temp)
{
Fraction temp1=temp;
*this=*this+temp1;
return *this;
};
Fraction& Fraction::operator-=(const Fraction& temp)
{
Fraction temp1=temp;
*this=*this-temp1;
return *this;
};
Fraction& Fraction::operator*=(const Fraction& temp)
{
Fraction temp1=temp;
*this=*this*temp1;
return *this;
};
Fraction& Fraction::operator/=(const Fraction& temp)
{
Fraction temp1=temp;
*this=*this/temp1;
return *this;
};
Fraction& Fraction::operator%=(const Fraction& temp)
{
Fraction temp1=temp;
*this=*this%temp1;
return *this;
};
Fraction Fraction::operator!()
{
int temp=(*this).iNumerator_;
(*this).iNumerator_=(*this).uiDenominator_;
(*this).uiDenominator_=temp;
return *this;
};
//OUTPUT STREAM
//AS this function is defined as friendly so class name is not given as this funcion is global
ostream& operator<<(ostream &output, const Fraction &temp)
{
if(temp.uiDenominator_==0)
output<<"inf";
else if(temp.uiDenominator_!=1)
output<<temp.iNumerator_<<"/"<<temp.uiDenominator_;
else
output<<temp.iNumerator_;
return output;
};
//INPUT STREAM
//AS this function is defined as friendly so class name is not given as this funcion is global
istream& operator>>(istream& input, Fraction& temp)
{
unsigned int den;
cout<<"Enter numerator::";
input>>temp.iNumerator_;
while(true)
{
cout<<"Enter denominator::";
input>>den;
if(den!=0)
{
temp.uiDenominator_=den;
break;
}else
cout<<"Denominator cannot be zero or negative"; //denominator should not be <=0
}
temp.Normalize(); //to normalize the fraction
return input;
};
#endif // __FRACTION_INL