home *** CD-ROM | disk | FTP | other *** search
/ Microsoftware Monthly 19…2 Programming Power Tools / MASO9512.ISO / cpptutor / cpptutor.arj / EXAMPLES / EX0900.H < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-20  |  5.7 KB  |  209 lines
  1. // \EXAMPLES\EX0900.H
  2. //  Definition of Fraction class
  3.  
  4. //  this file is used in the following example programs:
  5. //--------------------------------------------------------------
  6. // %F,15,EX0902.CPP%EX0902.CPP    overloading + - * /
  7. // %F,15,EX0903.CPP%EX0903.CPP    overloading unary + -
  8. // %F,15,EX0904.CPP%EX0904.CPP    overloading binary operators
  9. // %F,15,EX0905.CPP%EX0905.CPP    overloading =
  10. // %F,15,EX0906.CPP%EX0906.CPP    overloading prefix ++ --
  11. // %F,15,EX0907.CPP%EX0907.CPP    overloading postfix ++ --
  12. //---------------------------------------------------------------
  13. // This file must be used with
  14. // %F,15,EX0900.CPP%EX0900.CPP    Fraction members & friends
  15. //---------------------------------------------------------------
  16.  
  17.  
  18. #ifndef INCL_FRAC_H
  19. #define INCL_FRAC_H
  20.  
  21. #include <iostream.h>
  22.  
  23.  
  24.  // Fractions are always kept in simplest form
  25.  // always stored reduced to simplest form
  26. class Fraction
  27. {
  28.  
  29. private:
  30.  
  31.    int   num;        // numerator signed
  32.    int   denom;      // demoninator always positive
  33.    void  reduce ();  // reduces Fraction to simplest form
  34.    int               // used by reduce()
  35.    gcd( int n, int d);
  36.  
  37. public:
  38.    //------------------------------------------------------
  39.    // default constructor
  40.    //------------------------------------------------------
  41.    Fraction() : num(0), denom(1) {};
  42.  
  43.    //------------------------------------------------------
  44.    // constructor - conversion from 1 or 2 integers
  45.    //------------------------------------------------------
  46.    inline
  47.    Fraction( int i, int j = 1);
  48.  
  49.    //------------------------------------------------------
  50.    //conversion from real
  51.    //------------------------------------------------------
  52.    Fraction( double x);
  53.  
  54.    //------------------------------------------------------
  55.    // copy constructor
  56.    //------------------------------------------------------
  57.    inline
  58.    Fraction( const Fraction& source);
  59.  
  60.    //------------------------------------------------------
  61.    // assignment operator
  62.    //------------------------------------------------------
  63.    inline Fraction&
  64.    operator=( const Fraction& src);
  65.  
  66.    //------------------------------------------------------
  67.    // overloading >> and <<  for input and output
  68.    //------------------------------------------------------
  69.  
  70.    friend ostream&
  71.    operator<<( ostream&, const Fraction& );
  72.  
  73.    friend istream&
  74.    operator>>( istream&, Fraction& );
  75.  
  76.    //------------------------------------------------------
  77.    // overloading unary math operators + -
  78.    //------------------------------------------------------
  79.    inline Fraction operator+() const
  80.    { return *this; }
  81.  
  82.    inline Fraction operator-() const
  83.    { return Fraction(-num, denom); }
  84.  
  85.    //------------------------------------------------------
  86.    // overloading Prefix increment and decrement
  87.    //------------------------------------------------------
  88.    Fraction operator++()
  89.    { num += denom;
  90.      return *this;
  91.    }
  92.  
  93.    Fraction Fraction::operator--()
  94.    { num -= denom;
  95.      return *this;
  96.    }
  97.  
  98.    //------------------------------------------------------
  99.    // overloading Postfix increment and decrement
  100.    //------------------------------------------------------
  101.    inline Fraction operator++( int);
  102.    inline Fraction operator--( int);
  103.  
  104.    //------------------------------------------------------
  105.    // overloading binary math operators  +  -  *  /   ...
  106.    //------------------------------------------------------
  107.    inline Fraction
  108.    operator+( const Fraction& f) const;
  109.  
  110.    inline Fraction
  111.    operator-( const Fraction& f) const;
  112.  
  113.    inline Fraction
  114.    operator*( const Fraction& f) const;
  115.  
  116.    inline Fraction
  117.    operator/( const Fraction& f) const;
  118.  
  119. };
  120.  
  121. //----------------------------------------------------------
  122. // definition of inline member functions
  123. //----------------------------------------------------------
  124.  
  125. //----------------------------------------------------------
  126. // constructors
  127. //----------------------------------------------------------
  128.  
  129. inline
  130. Fraction::Fraction( int i, int j) : num(i), denom(j)
  131. {  if (denom != 1) reduce();
  132. }
  133.  
  134. inline
  135. Fraction::Fraction( const Fraction& source)
  136. {  num = source.num;
  137.    denom = source.denom;
  138. }
  139.  
  140. //------------------------------------------------------
  141. // assignment operator
  142. //------------------------------------------------------
  143.  
  144. inline Fraction&
  145. Fraction::operator=( const Fraction& src)
  146. {  num = src.num;
  147.    denom = src.denom;
  148.    return *this;
  149. }
  150.  
  151. //---------------------------------------------------------
  152. // binary arithmetic operators
  153. //---------------------------------------------------------
  154.  
  155. inline Fraction
  156. Fraction::operator+( const Fraction& f) const
  157. {
  158.   int n = (num * f.denom) + (f.num * denom);
  159.   int d = denom * f.denom;
  160.   return Fraction(n,d);
  161. }
  162.  
  163. inline Fraction
  164. Fraction::operator-( const Fraction& f) const
  165. {
  166.   int n = (num * f.denom) - (f.num * denom);
  167.   int d = (denom * f.denom);
  168.   return Fraction(n,d);
  169. }
  170.  
  171. inline Fraction
  172. Fraction::operator*( const Fraction& f) const
  173. {
  174.   int n = (num * f.num);
  175.   int d = (denom * f.denom);
  176.   return Fraction(n,d);
  177. }
  178.  
  179. inline Fraction
  180. Fraction::operator/( const Fraction& f) const
  181. {
  182.   int n = (num * f.denom);
  183.   int d = (denom * f.num);
  184.   return Fraction(n,d);
  185. }
  186.  
  187. //---------------------------------------------------------
  188. // Increment and Decrement operators postfix ++ --
  189. //---------------------------------------------------------
  190.  
  191. inline Fraction
  192. Fraction::operator++ (int)
  193. {
  194.    int oldNum = num;
  195.    num = num + denom;
  196.    return Fraction( oldNum, denom);
  197. }
  198.  
  199.  
  200. inline Fraction
  201. Fraction::operator-- (int)
  202. {
  203.    int oldNum = num;
  204.    num = num - denom;
  205.    return Fraction( oldNum, denom);
  206. }
  207.  
  208. #endif
  209.