lightbulb moment please: for overloaded function prototype

[marcia1010]

Need advice on overloaded function headers...I have an error message that reads "overloaded function not found".. in my class definition file. How do I write this correctly? I think the bodies of the functions are correct, but the program won't compile b/c of the mistake with the function prototype in concert with the member function header. The word "operator" is underlined in squiggly red font in the Visual Studio indicating that it doesn't like something...but what? I am obviously a new student and need a lightbulb moment here please. If I could see one of them right, I could fix them all. It is basically the same logic on all the overloaded operators. Sorry about all the comments, but my teacher requires them. Here's my .h and .cpp file code, plus the driver file which is written by our professor:

//driver Lab06_Rational_Driver.cpp

#include "RationalNumber.h"

int main()
{
    // RationalNumber c( 1, 3 ), d( 2, 4 ), x;
    RationalNumber c, d, x;

    // test overloaded stream extraction operator
    cout << "Enter a Rational Number (n/d): ";
    cin >> c;
    cout << "Enter a Rational Number (n/d): ";
    cin >> d;

    x = c + d; // test overloaded operators + and =
    cout << c << " + " << d << " = " << x << endl;

    x = c - d; // test overloaded operators - and =
    cout << c << " - " << d << " = " << x << endl;

    x = c * d; // test overloaded operators * and =
    cout << c << " * " << d << " = " << x << endl;

    x = c / d; // test overloaded operators / and =
    cout << c << " / " << d << " = " << x << endl;

    // test overloaded > operator
    cout << c << ( ( c > d ) ? " > " : " <= " ) << d
         << " according to the overloaded > operator\n";

    // test overloaded >= operator
    cout << c << ( ( c >= d ) ? " >= " : " < " ) << d
         << " according to the overloaded >= operator\n";

    // test overloaded < operator
    cout << c << ( ( c < d ) ? " < " : " >= " ) << d
         << " according to the overloaded < operator\n";

    // test overloaded <= operator
    cout << c << ( ( c <= d ) ? " <= " : " > " ) << d
         << " according to the overloaded <= operator\n";

    // test overloaded == operator
    cout << c << ( ( c == d ) ? " == " : " != " ) << d
         << " according to the overloaded == operator\n";

    // test overloaded != operator
    cout << c << ( ( c != d ) ? " != " : " == " ) << d
         << " according to the overloaded != operator\n";

    return 0;
} // end main




// RationalNumberClass.h
// 
#include <iostream>
using namespace std;

//prevents multiple inclusions of header
#ifndef RATIONALNUMBER_H
#define RATIONALNUMBER_H

class RationalNumber
{
	friend ostream &operator<<(ostream &, const RationalNumber & );  //overload stream insertion operator
	friend istream &operator>>(istream &, RationalNumber & );        //overload stream extraction operator
public:
	RationalNumber(int=1,int=1);   //constructor
	
	void setValues(int,int);  //mutator function to set data members
	void printRationalNumber();  //accessor display function - print fractions
	void printRationalAsDouble();  //accessor display function - print decimal answer
	int getNumerator();  //accessor read function 
	int getDenominator();   //accessor read function
	RationalNumber operator-(RationalNumber);   //overloaded subtr, binary 
	RationalNumber operator+(RationalNumber);   //overloaded add, binary 
	RationalNumber operator*(RationalNumber);   //overloaded multip, binary 
	RationalNumber operator/(RationalNumber);   //overloaded div, binary 
	bool operator<(RationalNumber);   //overloaded less than, binary 
	bool operator<=(RationalNumber);  //overloaded less than or equal to, binary  
	bool operator>(RationalNumber);   //overloaded greater than, binary 
	bool operator>=(RationalNumber);  //overloaded greater than or equal to, binary 
	bool operator==(RationalNumber);  //overloaded equality, binary  
	bool operator!=(RationalNumber);  //overloaded not equal, binary  
private:
	int numerator;  //data member
	int denominator;  //data member
	void reduction();  //prototype for utility function - reduce fraction
}; //end class RationalNumber

#endif


//RationalNumber.cpp     Exercise 11.10 Solution   
//RationalNumber class member-function definitions
//
#include <iostream>
#include <iomanip>
#include "RationalNumber.h"
using namespace std;

//constructor
RationalNumber::RationalNumber(int numer, int denom)
{
	setValues(numer,denom); //mutator function to set the values
	reduction();            //reduce the fraction to lowest form
}


void RationalNumber::setValues(int numer,int denom)   //mutator function to set values from object
{
	numerator=numer;
	denominator=denom;
}

void RationalNumber::reduction()                      //reduce the fraction to lowest form
{
	int largest;
	largest=numerator > denominator ? numerator : denominator;
	int gcd = 0;  //greatest common divisor
	for (int loop = 2; loop <= largest; loop++)
	{
		if (numerator % loop == 0 && denominator % loop == 0)
		{
			gcd = loop;
		}
	}
		if (gcd != 0)
		{
			numerator = numerator/gcd;
			denominator = denominator/gcd;
		} //end if
}

int RationalNumber::getNumerator()                      //access function
{
	return numerator;
}

int RationalNumber::getDenominator()                    //access function
{
	return denominator;
}


RationalNumber RationalNumber::operator-(RationalNumber operand2)        //subtract the fractions
{
	int newDenom = denominator *  operand2.getDenominator();
	int newNumA = numerator * operand2.getDenominator();
	int newNumB  = operand2.getNumerator() * denominator;
	int newNumTot = newNumA - newNumB;
	RationalNumber  y(newNumTot, newDenom);
	return y;
}


RationalNumber RationalNumber::operator+(RationalNumber operand2)        //add the fractions
{
	int newDenom = denominator *  operand2.getDenominator();
	int newNumA = numerator * operand2.getDenominator();
	int newNumB  = operand2.getNumerator() * denominator;
	int newNumTot = newNumA + newNumB;
	RationalNumber  y(newNumTot, newDenom);
	return y;
}

RationalNumber RationalNumber::operator*(RationalNumber &operand2)     //multiply the fractions
{
	int newDenom = denominator *  operand2.getDenominator();
	int newNum = numerator * operand2.getNumerator();
	RationalNumber  y(newNum, newDenom);
	return y;
}

RationalNumber RationalNumber::operator/(RationalNumber &operand2)          //divide the fractions
{
	int newDenom = denominator *  operand2.getNumerator();
	int newNum = numerator * operand2.getDenominator();
	RationalNumber  y(newNum, newDenom);
	return y;
}


bool  RationalNumber::operator<(RationalNumber &operand2)    //overloaded less than, binary
{
    int newNumA = numerator * operand2.getDenominator();
	int newNumB  = operand2.getNumerator() * denominator;
	if (newNumA < newNumB)
		return true;
	else
		return false;
}


bool  RationalNumber::operator<=(RationalNumber &operand2)  //overloaded less than or equal to, binary
{
	int newNumA = numerator * operand2.getDenominator();
	int newNumB  = operand2.getNumerator() * denominator;
	if (newNumA <= newNumB)
		return true;
	else
		return false;
}


bool  RationalNumber::operator>(RationalNumber &operand2)    //overloaded greater than, binary 
{
	int newNumA = numerator * operand2.getDenominator();
	int newNumB  = operand2.getNumerator() * denominator;
	if (newNumA > newNumB)
		return true;
	else
	    return false;
}


bool  RationalNumber::operator>=(RationalNumber &operand2)   //overloaded greater than or equal to, binary
{
	int newNumA = numerator * operand2.getDenominator();
	int newNumB  = operand2.getNumerator() * denominator;
	if (newNumA >= newNumB)
		return true;
	else
		return false;

}


bool  RationalNumber::operator==(RationalNumber &operand2)  //overloaded equality, binary
{
	int newNumA = numerator * operand2.getDenominator();
	int newNumB  = operand2.getNumerator() * denominator;
	if (newNumA = newNumB)
		return true;
	else
		return false;

}


bool  RationalNumber::operator!=(RationalNumber &operand2) //overloaded not equal, binary
{
	int newNumA = numerator * operand2.getDenominator();
	int newNumB  = operand2.getNumerator() * denominator;
	if (newNumA != newNumB)
		return true;
	else
		return false;

}

ostream &operator<<(ostream &output, const RationalNumber &number )    //overload stream insertion operator
{
	output << number.numerator << "/" << number.denominator;
	return output;
}

istream &operator>>(istream &input, RationalNumber &number )          //overload stream extraction operator
{
	input >> setw(1) >> number.numerator;
	input.ignore();
	input >> setw(1) >> number.denominator;
	return input;
}

[LB]

                RationalNumber operator*(RationalNumber); //overloaded multip, binary .
RationalNumber RationalNumber::operator*(RationalNumber &operand2) //multiply the fractions
RationalNumber (pass by value) is not the same as RationalNumber & (pass by reference)