Unexpected addition operator with my class

Question

I apologize if the question is Naive.

I am trying to overload the addition operator for fractions. My intent was to add fractions but for some reason it is adding the integers. Can some one explain why is it performing the integer addition. Code is below.

#include <iostream>
#include <string>

using namespace std;



class Fraction{
  long numerator;
  long denominator;
  long gcd(long num1, long num2);
  long lcm(long num1, long num2);
public:
  void convert_int_to_fraction(int num); 
  void reduce();
  Fraction(int num);
  Fraction(){
    numerator = 0;
    denominator = 0;
  }
  Fraction(long num, long den);
  Fraction operator+(Fraction fraction);
  friend ostream& operator<<(ostream& os, const Fraction& fracNumber);

};

void Fraction::convert_int_to_fraction(int num){
    denominator = 1;
    numerator = long(num);
    reduce();
}

Fraction::Fraction(int num){
    convert_int_to_fraction(num);
}

long Fraction::gcd(long num1, long num2){
    if(num1 == 0)
        return num2;
    else
        return (gcd(num2 % num1, num1));
}

//Math function to calculate LCM
long Fraction::lcm(long num1,  long num2){
    long great_Divisor = gcd(num1, num2);
    return ((num1/great_Divisor) * num2);
}

//Reduce fraction to its minimal
void Fraction::reduce(){
    if(denominator!=0){
        long great_Divisor = gcd(numerator, denominator);
        numerator /= great_Divisor;
        denominator /= great_Divisor;
        if(denominator < 0 && numerator > 0){
            denominator = -denominator;
            numerator = -numerator;
        }
    }
}

Fraction::Fraction(long num, long den):numerator(num), denominator(den){
    reduce();
}

ostream& operator<<(ostream& os, const Fraction& fracNumber){
    os << fracNumber.numerator << "/" << fracNumber.denominator ;
    return os;
}

Fraction Fraction::operator+(Fraction fraction){
    Fraction result;
    long least_Multiple = lcm(denominator, fraction.denominator);
    result.denominator = (least_Multiple);
    long result_Numerator = ((numerator * (least_Multiple/denominator)) + 
                                (fraction.numerator * (least_Multiple/fraction.denominator)));
    result.numerator = (result_Numerator);
    result.reduce();
    return result;
}

int main(){
  Fraction frac1(2,4);
  cout << frac1 + 2  << endl;
  return 0;
}

The output is 5/2 So I tried to do it the other way round

  cout << 2 + frac1   << endl;

This is giving me error. So now I tried to fix this by implementing these two functions.

Fraction::operator int(){
    return convert_fraction_to_int();
}
int Fraction::convert_fraction_to_int(){
    return ((int)(numerator/denominator));
}

Now even the first operation cout doesnt work. But the best thing is everything works fine when I typecast the variables. Can anyone explain why it is working in the first case, why not in the second case and why broken in the third case.

Answer 1

.My intent was to add fractions but for some reason it is adding the integers. Can some one explain why is it performing the integer addition.

There is a converting constructor from int to Fraction.

frac1 + 2 is being converted to frac1 + Fraction(2) by the compiler.

Update

If you want the compiler to be able support both frac1 + 2 and 2 + frac1, you can make the operator+ function a non-member function.

friend Fraction operator+(Fraction const& lhs, Fraction const& rhs);

and implement it as:

Fraction operator+(Fraction const& lhs, Fraction const& rhs)
{
   Fraction result;

   // Needed to make lcm and gcd static member functions since
   // they work independent of the member variables.

   long least_Multiple = Fraction::lcm(lhs.denominator, rhs.denominator);
   result.denominator = (least_Multiple);
   long result_Numerator = ((lhs.numerator * (least_Multiple/lhs.denominator)) + 
                            (rhs.numerator * (least_Multiple/rhs.denominator)));
   result.numerator = (result_Numerator);
   result.reduce();
   return result;
}

Now, you can use

Fraction frac1(2,4);
Fraction frac2(3,7);
cout << frac1 + 2  << endl;
cout << 3 + frac1  << endl;
cout << frac1 + frac2 << endl;