I'm writing a class for rational numbers, and am doing a lot of operator overloading. I'm getting an error on my overloaded "<<":

u:\Program4\Program4.cpp(16): error C2679: binary '<<' : no operator found which takes a right-hand operand of type 'Rational' (or there is no acceptable conversion)

I've searched Google, but haven't been able to find anything that helps yet. Anyone have any suggestions?

Thanks in advance! :-)

///////////////////////////////////
// Rational.h
///////////////////////////////////

#ifndef RATIONAL_CPP
#define RATIONAL_CPP

class Rational
{
   // Binary operators

   friend Rational operator+ (const Rational &r, const Rational &r2)
   {
      Rational rNum( ((r2.numerator * r.denominator) + (r2.denominator * r.numerator)), (r2.denominator * r.denominator) );
      return rNum;
   }

   friend Rational operator- (const Rational &r, const Rational &r2)
   {
      Rational rNum( ((r2.numerator * r.denominator) - (r2.denominator * r.numerator)), (r2.denominator * r.denominator) );
      return rNum;
   }

   friend Rational operator* (const Rational &r, const Rational &r2)
   {
      Rational rNum((r2.numerator * r.numerator), (r2.denominator * r.denominator));
      return rNum;
   }

   friend Rational operator/ (const Rational &r, const Rational &r2)
   {
      // (a d) / (b c)
      Rational rNum((r2.numerator * r.denominator), (r2.denominator * r.numerator));
      return rNum;
   }

   // Unary operator
   friend Rational operator- (const Rational &r)
   {
      Rational r2((r.numerator * (-1)), r.denominator);
      return r2;
   }

   // Comparison operators
   friend bool operator< (const Rational &r, const Rational &r2)
   {
      return ( (r2.numerator * r.denominator) < (r2.denominator * r.numerator) );
   }

   friend bool operator<= (const Rational &r, const Rational &r2)
   {
      return ( (r2.numerator * r.denominator) <= (r2.denominator * r.numerator) );
   }

   friend bool operator> (const Rational &r, const Rational &r2)
   {
      return ( (r2.numerator * r.denominator) > (r2.denominator * r.numerator));
   }

   friend bool operator>= (const Rational &r, const Rational &r2)
   {
      return ( (r2.numerator * r.denominator) >= (r2.denominator * r.numerator) );
   }

   friend bool operator== (const Rational &r, const Rational &r2)
   {
      if((r2.numerator == r.numerator) && (r2.denominator == r.denominator))
         return true;
      else
         return false;
   }

   friend bool operator!= (const Rational &r, const Rational &r2)
   {
      if((r2.numerator != r.numerator) && (r2.denominator != r.denominator))
         return true;
      else
         return false;
   }

   friend Rational abs(const Rational &r)
   {
      Rational rNew(r);

      if(r.numerator < 0)
         rNew.numerator *= (-1);

      if(r.denominator < 0)
         rNew.denominator *= (-1);

      return rNew;
   }

   private:
      int numerator;
      int denominator;
   public:
      Rational(const int num = 0, const int denom = 1);  // default (initial value zero, 0 / 1)
      Rational();
      Rational(const Rational&);             // copy constructor
      int num() const;                       // retrieve numerator
      int denom()const;                      // retrieve denominator
      // Output operator
      ostream& operator<< (ostream&);

      // Assignment operators
      Rational operator= (const Rational &r);
      Rational operator+= (const Rational &r);
      Rational operator-= (const Rational &r);
      Rational operator*= (const Rational &r);
      Rational operator/= (const Rational &r);
};

#endif



///////////////////////////////////
// Rational.cpp
///////////////////////////////////

#include 
using namespace std;

#include "Rational.h"

// Main constructor
Rational::Rational(const int num, const int denom)
{
   numerator = num;
   denominator = denom;
}

Rational::Rational()
{
   numerator = 0;
   denominator = 1;
}
// Copy constructor
Rational::Rational(const Rational &r)
{
   numerator = r.num();
   denominator = r.denom();
}

int Rational::num() const
{
   return numerator;
}

int Rational::denom() const
{
   return denominator;
}

// Binary operators

ostream& Rational::operator<< (ostream& output)
{
   output << numerator << "/" << denominator;
   return output;
}

// Assignment operators

Rational Rational::operator= (const Rational& r)
{
   Rational rNum(r.numerator, r.denominator);
   return rNum;
}

Rational Rational::operator+= (const Rational& r)
{
   Rational rNum = *this + r;
   return rNum;
}

Rational Rational::operator-= (const Rational& r)
{
   Rational rNum = *this - r;
   return rNum;
}

Rational Rational::operator*= (const Rational& r)
{
   Rational rNum((numerator *= r.numerator), (denominator *= r.denominator));
   return rNum;
}

Rational Rational::operator/= (const Rational& r)
{
   Rational rNum((numerator /= r.denominator), (denominator /= r.numerator));
   return rNum;
}


///////////////////////////////////
// Program4.cpp
///////////////////////////////////

#include 
using namespace std;

#include "Rational.h"

int main()
{
   Rational r1();       // initialize to 0
   Rational r2(5);      // initialize to 5
   Rational r3(1, 3);   // initialize to 1/3
   Rational r4(1, 2);   // initialize to 1/2
   Rational r5(2, 5);   // initialize to 2/5

   cout << "r1 == " << r1;
   cout << "r2 == " << r2;  // Line with error

   char chExit;
   cin >> chExit;

   return 0;
}