C++ Fraction Calculator using Classes and Functions - c++

Question

I am new to StackOverflow, and starting at a new school. I was hoping for some guidance on an assignment. The assignment is to calculate an expression involving two fractions, and output the result. I've been working on this program for days with the knowledge from my textbook, but I guess I am still confused on how to implement functions within a class. I know what I want to do with my values, but I am confused on where to assign them. I tried to read in my values, but when outputting, I get garbage. Any help would be greatly appreciated.
#include <iostream>
using namespace std;
class fraction // Fraction class definition
{
int num,
den;
public:
fraction() // default constructor
{
num = 0;
den = 1;
}
void add(fraction f1, fraction f2) // addition fcn
{
num = (f1.num*f2.den) + (f2.num*f1.den);
den = f1.den*f2.den;
}
void subtract(fraction f1, fraction f2) // subtraction fcn
{
num = (f1.num*f2.den) - (f2.num*f1.den);
den = f1.den*f2.den;
}
void multiply(fraction f1, fraction f2) // multiplying fcn
{
num = f1.num*f2.num;
den = f1.den*f2.den;
}
void divide(fraction f1, fraction f2) // dividing fcn
{
num = f1.num*f2.den;
den = f1.den*f2.num;
}
void output()
{
cout << num << "/" << den << endl;
}
}; // end Fraction class
int main()
{ // begin main
fraction result;
fraction n;
fraction d;
int n1, n2, d1, d2 = 0;
char op;
cout << "Please enter an expression containing two fractions:" << endl;
cin >> n1 >> d1 >> op >> n2 >> d2;
switch (op)
{ // begin switch
case '+':
result.add(n, d);
result.output();
break;
case '-':
result.subtract(n, d);
result.output();
break;
case '*':
result.multiply(n, d);
result.output();
break;
case'/':
result.divide(n, d);
result.output();
break;
} // end switch
//fraction f1(n1, d1);
//fraction f2(n2, d2);
} // end main

Answer 1

The actual answer was given in the very first comment of John3136. Hence, I struggled a bit but finally realized that you probably didn't recognize. So, I will elaborate this a bit:
In main(), you do this:
int n1, n2, d1, d2 = 0;
char op;
cout << "Please enter an expression containing two fractions:" << endl;
cin >> n1 >> d1 >> op >> n2 >> d2;
Stepping through with a debugger, you will realize that this part of program works as expected. After input of e.g.
1 2 + 3 4
the variables will show the following values:
n1: 1
d1: 2
n2: 3
d2: 4
op: '+'
Live demo on ideone
Stepping further, the program pointer will move to
result.add(n, d);
Hmm. You want to add n and d but the debugger says:
n: { num: 0, den: 1 }
d: { num: 0, den: 1 }
The values of n.num, n.den, d.num, and d.den are there as you provided a default constructor for class fraction which effects precisely this.
So, how do you think will n1 be moved to n.num, d1 to n.den, and so on?
What's really missing is a constructor for class fraction to load members num and den (in this case of n and d) with the specified values.
You could introduce a second constructor. In this case, you can modify (and extend) your existing, also:
class fraction {
private:
int num, den; // numerator, denominator
public:
explicit fraction(int num = 0, int den = 1): num(num), den(den) { }
};
Looks confusing? I will explain:
I gave the constructor arguments, but the arguments got default values.
Hence, it still can be used as default constructor. Doing fraction a; will construct fraction 0/1 as before. But, now, you can also do fraction b(3, 2); to construct fraction 3/2. You can even do fraction d(3);. This will construct fraction 3/1 which sounds reasonable to me.
I named the arguments equal to the members. Looks funny and, may be, a bit confusing but it seems to be very usual nowadays. (Actually, I learned this in SO a short time ago.) However, the compiler will understand this correctly (even if it is the one of MS).
I prefixed the constructor with explicit. This prevents that the constructor might be used for implicit conversion. Without explicit, the following would work as well: fraction c; c = 1; i.e. assignment of class fraction from an int. This is a question of design whether or not you want to support this. Implicit conversion can be quite convenient but the compiler might apply it where you don't expect it. I personally got used to make nearly every constructor explicit as I don't like to "lose control" of what the compiler is doing.
Modifying the above constructor as recommended you then can use your class, e.g.:
fraction a(3, 2), b(1, 2);
fraction result; result.add(a, b);
result.output();
Now, it should print the sum of fractions a and b.
A last note:
I consider O'Neil's hint with the operator overloading basically reasonable. You will find answers with code samples in SO. (Some of them, written by me.) ;-) On the other hand, operator overloading is just another handicap. I wouldn't bother too much about this. (May be, in a second version...)
Finally, I made an MCVE to demonstrate the above mentioned with sample code:
#include <iostream>
using namespace std;
class fraction {
private:
int num, den; // numerator, denominator
public:
explicit fraction(int num = 0, int den = 1): num(num), den(den) { }
void add(fraction f1, fraction f2) // addition fcn
{
num = (f1.num * f2.den) + (f2.num * f1.den);
den = f1.den * f2.den;
}
void output() { cout << num << "/" << den << endl; }
};
int main()
{
fraction a0;
cout << "fraction a0: "; a0.output();
fraction a(3, 2), b(1);
cout << "fraction a(3, 2): "; a.output();
cout << "fraction b(1): "; b.output();
fraction c; c.add(a, b);
cout << "fraction c = a + b: "; c.output();
// assignment (using default assignment operator)
fraction d; d = c;
cout << "faction d = c; d: "; d.output();
#if 0 // disabled code
// This will work only if constructor is not explicit:
fraction e = 1; e = 1;
cout << "fraction e; e = 1; e: "; e.output();
#endif // 0
// fraction from input
int n1, n2;
cout << "Input n1 n2: "; cin >> n1 >> n2;
fraction in(n1, n2);
cout << "fraction in(n1, n2): "; in.output();
// done
return 0;
}
Input:
123 321
Output:
fraction a0: 0/1
fraction a(3, 2): 3/2
fraction b(1): 1/1
fraction c = a + b: 5/2
faction d = c; d: 5/2
Input n1 n2: fraction in(n1, n2): 123/321
Live demo on ideone.
After having read your comment, I'm in doubt whether you already understood the concept of class and member function. I'll try my best:
Are you aware that your function add() is a member function? It is as you defined the function inside your class fraction. That means, add() cannot be called without an object (i.e. an instance of fraction).
If you write this into your main() function you get a compiler error:
fraction a, b;
fraction::add(a, b);
Live demo on ideone
The object is another argument that a call of a (non-static) member function (like fraction::add()) urgently needs. May be, you didn't recognize the thing in front of the dot as function argument but it is.
fraction c; c.add(a, b);
/* ^ ^ ^
* | | +--- 2nd argument
* | +------ 1st argument
* +------------ object (which becomes THE this POINTER inside fraction::add())
*/
Hence, fraction.add() has actually three arguments. So, how may the object be accessed? For this, C++ provides a special keyword this. this is a pointer to class, and it provides a pointer to the object for which the member function has been called. Using this, you can access all (other) members of this class – member variables as well as member functions.
(Decades ago, when I tried to understand by myself how C++ and OOP are working, I had a look into the compiled assembly code. I was really surprised to realize that the object before the dot was exactly handled like the other arguments in the parentheses. This was one of my personal Heureka!-moments.)
Access to members (of the same class) can be done inside a member function with this-> but it can be left out as well as the compiler will add this silently if applicable.
Your member function fraction::add() is actually a demonstration of this.
It gets two arguments f1 and f2, processes their members (f1.num, f1.den, f2.num, and f2.den) to perform the addition of fractions, and stores the resp. results in member variables num and den. In this case, num is the same as this->num and den the same as this->den. So, where is this pointing to? This depends on the object for which the member function has been called. For e.g.:
result.add(n, d);
inside of fraction::add(), this will point to result.