C++ simple friction question. Please check on fraction.cpp file(overloaded operating) What I missed.

friction.h

class Fraction

{

private:

int getGCD( int num1, int num2 );

int numerator;

int denominator;

public:

Fraction()

{

numerator = 0;

denominator = 0;

}

Fraction(int n, int d);

void reduce();

int getNumerator();

int getDenominator();

void setNumerator(int n);

void setDenominator(int d);

const Fraction operator+(Fraction rhs);

const Fraction operator-(Fraction rhs);

const Fraction operator*(Fraction rhs);

const Fraction operator/(Fraction rhs);

bool operator==(Fraction rhs);

friend ostream& operator<< (ostream& output, const Fraction& Fract);

friend istream& operator>> (istream& input, Fraction& Fract);

};

friction.cpp

#include "Fraction.h"

#include

#include

using namespace std;

// Find the greatest common denominator (GCD)

// For reducing

int Fraction::getGCD( int num1, int num2 )

{

int remainder = num2 % num1;

if ( remainder != 0 )

return getGCD( remainder, num1 );

return num1;

}

// Reduce/simplify a fraction

void Fraction::reduce()

{

// Alter this function later to adjust for negative values

int gcd = getGCD(numerator, denominator);

numerator /= gcd;

denominator /= gcd;

if (denominator < 0) {

numerator == -numerator;

denominator == -denominator;

}

else if (numerator < 0 && denominator < 0)

{

numerator == -numerator;

denominator == -denominator;

}

}

Fraction::Fraction(int n, int d)

{

n = numerator;

d = denominator;

}

int Fraction::getNumerator()

{

return numerator;

}

void Fraction::setNumerator(int n)

{

numerator = n;

}

int Fraction::getDenominator()

{

return denominator;

}

void Fraction::setDenominator(int d)

{

denominator = d;

}

ostream& operator<< (ostream& output, const Fraction& Fract) {

output << Fract.numerator << '/' << Fract.denominator;

return output;

}

istream& operator>> (istream& input, Fraction& Fract) {

char slash;

input >> Fract.numerator >> slash >> Fract.denominator;

return input;

}

const Fraction Fraction::operator+(Fraction rhs)

{

Fraction add(numerator*rhs.denominator + rhs.numerator*denominator, denominator*rhs.denominator);

reduce();

return add;

}

const Fraction Fraction::operator-(Fraction rhs)

{

Fraction sub(numerator*rhs.denominator - rhs.numerator*denominator, denominator*rhs.denominator);

reduce();

return sub;

}

const Fraction Fraction::operator*(Fraction rhs)

{

Fraction mult(numerator*rhs.numerator, denominator*rhs.denominator);

reduce();

return mult;

}

const Fraction Fraction::operator/(Fraction rhs)

{

Fraction div(numerator*rhs.denominator, denominator*rhs.numerator);

reduce();

return div;

}

bool Fraction::operator==(Fraction rhs)

{

Fraction reduce();

if (rhs.numerator == numerator && rhs.denominator == denominator)

return true;

else

return false;

}

What I missed on here?