When I run the following program, I get a fraction that is 0/0 and I have no ide

Question

When I run the following program, I get a fraction that is 0/0 and I have no idea why
///////


code: Client Function:

#include "fractions.h"

int main()
{

int den3, num3;
cout<<"Enter a numerator for a fraction: ";
cin>>num3;
cout<<"Enter a denominator for a fraction: ";
cin>>den3;
Fraction f1(11,4);
Fraction f2(2, 5);
Fraction f3(num3, den3);
Fraction f4(10,20);


Fraction reci = f3.Reciprocal();
Fraction multi = f2 * f3;
Fraction add = multi + f2;
//Fraction redu = f4.Reduce();

cout<
char wait;
cout <<"Enter any key to quit.";
cin >> wait;

system("pause");
return 0;
}

Class Function:

#include "fractions.h"

// implementation
Fraction::Fraction()
{

}

Fraction::Fraction(int n, int d)
{
// create a fraction and fill it
n = num;
if(d!=0)
{d = den;}
else
{cout<<"Error: no division by 0"<}

int Fraction::GCF()
{
int gcf;
bool done = false;
if (num <= den)
{ gcf = num;}
else
{ gcf = den;}
while (!done && gcf > 1)
{
if (num % gcf == 0 && den % gfc == 0)
{done = true;}
else
{gcf--; }
}
return gfc;
}

//Arithmetic operators
//Fraction Fraction :: operator* (Fraction f)
//return name of class scope name of function perameter list
Fraction Fraction :: operator*(Fraction f)
{
Fraction temp;
temp.num = num * f.num;
temp.den = den * f.den;
temp.Reduce();
return temp;
}

Fraction Fraction :: operator/(Fraction f)
{
Fraction temp;
temp.num = num * f.den;
temp.den = den * f.num;
temp.Reduce();
return temp;
}

Fraction Fraction :: operator+(Fraction f)
{
Fraction temp;
temp.den = den * f.den;
temp.num = (den * f.num) + (num * f.den);
temp.Reduce();
return temp;
}

Fraction Fraction :: operator-(Fraction f)
{
Fraction temp;
temp.den = den * f.den;
temp.num = (den * f.num) - (num * f.den);
temp.Reduce();
return temp;
}

double Fraction :: Decimal()
{
double dec;
dec = static_cast (num)/(den);
return dec;
}

void Fraction::Reduce()
{
int gcf = GCF();
num = num / gcf;
den = den / gcf;
}

ostream& operator<<(ostream& outs, const Fraction f)
{
outs< return outs;
}

void Fraction::Display()
{
int num = GetNum();
int dem = GetDen();
cout<}

Fraction Fraction::Reciprocal()
{
Fraction temp;
temp.den = num;
temp.num = den;
return temp;
}

bool Fraction :: operator< (Fraction f)
{return Decimal()< f.Decimal();}

bool Fraction :: operator > (Fraction f)
{return Decimal()> f.Decimal();}

bool Fraction :: operator == (Fraction f)
{return Decimal()== f.Decimal();}

int Fraction::GetNum()
{
return num;
}

int Fraction::GetDen()
{
return den;
}

Header:
#include
using namespace std;

class Fraction
{
public:
Fraction(); // default constructor, says that Fraction can exist
Fraction(int n, int d); //alternate constructor

void Reduce();//change fraction to its least form
double Decimal();//returns in decimal form
void Display();//shows the fraction in the form numerator / dem
int GetNum();//sends the numerator
int GetDen();//sends denominator
int GCF();

Fraction Reciprocal();

Fraction operator + (Fraction f);
Fraction operator - (Fraction f);
Fraction operator * (Fraction f);
Fraction operator / (Fraction f);// creates a new fraction which is the sum
// of the calling object and f. <-- Same for all of the operators
bool operator < (Fraction f);// returns either true or false
bool operator > (Fraction f);
bool operator == (Fraction f);
friend ostream& operator << (ostream& outs, const Fraction f);
//convert double to fraction (extra credit)

private:
int num, den, gfc;
};


/////////////

so client calls the class
and its function
and by using the functions that are in the class
with 3 fractions i should get following output:

3/4 has reciprocal 4/3

3/10 = 2/5 * 3/4

3/10 + 2/5 = 7/10

10 / 20 = 1/2

1/2 = 0.5

3/10 < 2/5

3/4 > 2/5

3/4 = 0.75

Explanation / Answer

your bug is in your GCF() function. You mistake gcf and gfc...

///Fraction.h

#include <iostream>
using namespace std;

#ifndef FRACTION_H
#define FRACTION_H

class Fraction
{
public:
   Fraction(); // default constructor, says that Fraction can exist
   Fraction(int n, int d); //alternate constructor

   void Reduce();//change fraction to its least form
   double Decimal();//returns in decimal form
   void Display();//shows the fraction in the form numerator / dem
   int GetNum();//sends the numerator
   int GetDen();//sends denominator
   int GCF();

   Fraction Reciprocal();

   Fraction operator + (Fraction& f);
   Fraction operator - (Fraction& f);
   Fraction operator * (Fraction& f);
   Fraction operator / (Fraction& f);// creates a new fraction which is the sum
   // of the calling object and f. <-- Same for all of the operators
   bool operator < (Fraction& f);// returns either true or false
   bool operator > (Fraction& f);
   bool operator == (Fraction& f);
   friend ostream& operator << (ostream& outs, const Fraction& f);
   //convert double to fraction (extra credit)

private:
   int num, den, gfc;
};
#endif

///Fraction.cpp

#include "Fraction.h"

// implementation
Fraction::Fraction()
{
}

Fraction::Fraction(int n, int d)
{
   // create a fraction and fill it
   num = n;
   if(d != 0)
      den = d;
   else
      cout << "Error: no division by 0" << endl;
}

int Fraction::GCF()
{
   int gcf;
   if (num <= den)
      gcf = num;
   else
      gcf = den;
   while (gcf > 1)
   {
      if (num % gcf == 0 && den % gcf == 0)
         break; //you don't need an extra boolean 'done' here. Use break statement instead.
      else
         gcf--;
   }
   return gcf;
}

//Arithmetic operators
//Fraction Fraction :: operator* (Fraction f)
//return name of class scope name of function perameter list
Fraction Fraction :: operator*(Fraction& f)
{
   Fraction temp;
   temp.num = num * f.num;
   temp.den = den * f.den;
   temp.Reduce();
   return temp;
}

Fraction Fraction :: operator/(Fraction& f)
{
   Fraction temp;
   temp.num = num * f.den;
   temp.den = den * f.num;
   temp.Reduce();
   return temp;
}

Fraction Fraction :: operator+(Fraction& f)
{
   Fraction temp;
   temp.den = den * f.den;
   temp.num = (den * f.num) + (num * f.den);
   temp.Reduce();
   return temp;
}

Fraction Fraction :: operator-(Fraction& f)
{
   Fraction temp;
   temp.den = den * f.den;
   temp.num = (den * f.num) - (num * f.den);
   temp.Reduce();
   return temp;
}

double Fraction :: Decimal()
{
   double dec;
   dec = static_cast<double> (num)/(den);
   return dec;
}

void Fraction::Reduce()
{
   int gcf = GCF();
   num = num / gcf;
   den = den / gcf;
}

ostream& operator<<(ostream& outs, const Fraction& f)
{
   outs << f.num << "/" << f.den;
   return outs;
}

void Fraction::Display()
{
   int num = GetNum();
   int dem = GetDen();
   cout << num << "/" << dem;
}

Fraction Fraction::Reciprocal()
{
   Fraction temp;
   temp.den = num;
   temp.num = den;
   return temp;
}

bool Fraction :: operator< (Fraction& f)
{return Decimal()< f.Decimal();}

bool Fraction :: operator > (Fraction& f)
{return Decimal()> f.Decimal();}

bool Fraction :: operator == (Fraction& f)
{return Decimal()== f.Decimal();}

int Fraction::GetNum()
{
   return num;
}

int Fraction::GetDen()
{
   return den;
}

///driver.cpp (please implement your own test driver. I wrote my test driver)

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

int main()
{
   int den3, num3;
   cout<<"Enter a numerator for a fraction: ";
   cin>>num3;
   cout<<"Enter a denominator for a fraction: ";
   cin>>den3;
   Fraction f1(11,4);
   Fraction f2(2, 5);
   Fraction f3(num3, den3);
   Fraction f4(10,20);

   cout << f1 << endl;
   cout << f2 << endl;
   cout << f3 << endl;
   cout << f4 << endl;

   Fraction reci = f3.Reciprocal();
   Fraction multi = f2 * f3;
   Fraction add = multi + f2;

   cout << endl;
   cout << "1 / (" << f3 << ") = " << reci << endl;
   cout << f2 << " * " << f3 << " = " << multi << endl;
   cout << multi << " + " << f2 << " = " << add << endl;
   cout << f4 << " = ";
   f4.Reduce();
   cout << f4 << endl;

   cout << " Enter any key to quit. ";
   cin.sync();
   cin.get();
   return 0;
}

Related Questions

Navigate

• Browse (All)
• Browse W
• Subjects

---

---

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.