Script started on Sun Nov 21 17:32:55 1999
pluto[5:32pm] [~/c++/]>	cat rational-overload.h

// rational-overload.h
// header file containing
// class declaration for
// RationalNumber class
// implementation in rational-overload.cc
// Problem 8.17 in D&D
#ifndef rational_H
#define rational_H
#include <iostream.h>

class RationalNumber
{
  friend ostream &operator<<(ostream &, const RationalNumber &);
  friend istream &operator>>(istream &, RationalNumber &);  
 public:
  // default constructor
  RationalNumber(int = 0, int = 1);
  // overload operators for "normal" operation
  RationalNumber operator+(const RationalNumber&);
  RationalNumber operator-(const RationalNumber&);
  RationalNumber operator*(const RationalNumber&);
  RationalNumber operator/(const RationalNumber&);
  // overload relational operators for "normal" operation
  int operator>(const RationalNumber&) const;
  int operator<(const RationalNumber&) const;
  int operator>=(const RationalNumber&) const;
  int operator<=(const RationalNumber&) const;
  int operator==(const RationalNumber&) const;
  int operator!=(const RationalNumber&) const;
 private:
  int numerator;
  int denominator;
  void reduction(void);
};
#endif
pluto[5:33pm] [~/c++/]>	cat rational-overload.cc

// rational-overload.cc
// member function definitions for
// RationalNumber class
// Problem 8.17 in D&D
#include <stdlib.h>
#include "rational-overload.h"

// default constructor default values 0 and 1
RationalNumber::RationalNumber(int num, int denom)
{
  numerator = num;
  denominator = (denom > 0) ? denom : 1;
  reduction();
}

// overload operators for "normal" operation
RationalNumber 
 RationalNumber::operator+(const RationalNumber &a)
{
  RationalNumber sum;

  sum.numerator = numerator * a.denominator +
                  denominator * a.numerator;
  sum.denominator = denominator * a.denominator;
  sum.reduction();
  return sum;
}

RationalNumber 
 RationalNumber::operator-(const RationalNumber &a)
{
  RationalNumber sub;

  sub.numerator = numerator * a.denominator -
                  denominator * a.numerator;
  sub.denominator = denominator * a.denominator;
  sub.reduction();
  return sub;
}

RationalNumber 
 RationalNumber::operator*(const RationalNumber &m)
{
  RationalNumber multiply;

  multiply.numerator = numerator * m.numerator;
  multiply.denominator = denominator * m.denominator;
  multiply.reduction();
  return multiply;
}

RationalNumber 
 RationalNumber::operator/(const RationalNumber &d)
{
RationalNumber divide;
if (d.numerator != 0)
  {
    divide.numerator = numerator * d.denominator;
    divide.denominator = denominator * d.numerator;
    divide.reduction();
  }
else
  {
    cout << "Divide by zero error: terminating program" << endl;
    exit(1);
  }
return divide;
}

// overload relational operators for "normal" operation
int RationalNumber::operator>(const RationalNumber &gr) const
{
  if ((float)numerator / denominator > 
      (float)gr.numerator / gr.denominator)
    return 1;
  else
    return 0;
}

int RationalNumber::operator<(const RationalNumber &lr) const
{
  if ((float)numerator / denominator <
      (float)lr.numerator / lr.denominator)
    return 1;
  else
    return 0;
}

// can use previous definitions in following
int 
 RationalNumber::operator>=(const RationalNumber &ger) const
{
  return *this == ger || *this > ger;
}

int 
 RationalNumber::operator<=(const RationalNumber &ler) const
{
  return *this == ler || *this < ler;
}

int 
 RationalNumber::operator==(const RationalNumber &er) const
{
  if (numerator == er.numerator &&
      denominator == er.denominator)
    return 1;
  else
    return 0;
}

int 
 RationalNumber::operator!=(const RationalNumber &ner) const
{
  return !(*this == ner);
}

void RationalNumber::reduction(void)
{
  int largest, gcd = 1;
  largest = (numerator > denominator) ? numerator : denominator;
  
  for (int loop = 2; loop <= largest; loop++)
    if (numerator % loop == 0 && denominator % loop == 0)
      gcd = loop;

  numerator /= gcd;
  denominator /= gcd;
}

ostream & 
  operator<<(ostream &output, const RationalNumber &rnum)
{
  output << rnum.numerator << "/" << rnum.denominator;
  return output;
}

istream&
  operator>>(istream &input, RationalNumber &rnum)
{
  input >> rnum.numerator;
  input.ignore(1);
  input >> rnum.denominator;
  return input;
}
  
pluto[5:33pm] [~/c++/]>	cat rational-overload-driver.cc

// rational-overload-driver.cc
// driver for RationalNumber class
// problem 8.17 in D&D
#include "rational-overload.h"

main()
{
  RationalNumber c(7,3), d(3,9), x;

  cout << c << " + " << d << " = ";
  x = c + d;
  cout << x << endl;

  cout << c << " - " << d << " = ";
  x = c - d;
  cout << x << endl;

  cout << c << " * " << d << " = ";
  x = c * d;
  cout << x << endl;

  cout << c << " / " << d << " = ";
  x = c / d;
  cout << x << endl;

  cout << c << " is: " << endl;

  cout << ((c > d) ? " > " : " <= ")
       << d
       << " according to the overloaded > operator" 
       << endl;

  cout << ((c < d) ? " < " : " >= ")
       << d
       << " according to the overloaded < operator" 
       << endl;

  cout << ((c >= d) ? " >= " : " < ")
       << d
       << " according to the overloaded >= operator" 
       << endl;

  cout << ((c <= d) ? " <= " : " > ")
       << d
       << " according to the overloaded <= operator" 
       << endl;

  cout << ((c == d) ? " == " : " != ")
       << d
       << " according to the overloaded == operator" 
       << endl;

  cout << ((c != d) ? " != " : " == ")
       << d
       << " according to the overloaded != operator" 
       << endl;

   cout << "Input a RationalNumer num/denom: ";
   cin >> x;
   cout << x;
	   cout << endl;

	   return 0;
	 }
pluto[5:33pm] [~/c++/]>	CC -compat rational-overload.cc rational-overload-driver
.cc

rational-overload.cc:
rational-overload-driver.cc:
pluto[5:33pm] [~/c++/]>	a.out

7/3 + 1/3 = 8/3
7/3 - 1/3 = 2/1
7/3 * 1/3 = 7/9
7/3 / 1/3 = 7/1
7/3 is: 
 > 1/3 according to the overloaded > operator
 >= 1/3 according to the overloaded < operator
 >= 1/3 according to the overloaded >= operator
 > 1/3 according to the overloaded <= operator
 != 1/3 according to the overloaded == operator
 != 1/3 according to the overloaded != operator
Input a RationalNumer num/denom: 5/7
5/7
pluto[5:33pm] [~/c++/]>	exit

exit

script done on Sun Nov 21 17:33:48 1999