fraction.cpp

实现了分数之间的四则运算

#include "fraction.h" //include definition of fraction

int count(int a)
{
   int k;
   for( k =1; a != 0; k++)
       a = a / 10;
   return k;
}

fraction::fraction( int a=0, int b=1)
:numerator(a),
 denominator(b) //constructor
{ 
  if (b==0)
    cout << "The denominator can NOT be zero!"<<endl;
}

fraction::~fraction(void)   //destructor
{
}

void fraction::set_denominator( int a )
{
     denominator = a;     
}

void fraction::set_numerator( int a )
{
     numerator = a;
}

void fraction::set_fraction( int a, int b)
{
     set_numerator(a);
     set_denominator(b);
}

int fraction::get_numerator()
{
     return numerator;    
}

int fraction::get_denominator()
{
     return denominator;
}

void fraction::simplify()
{
     int a = denominator, b = numerator;
     int c;
     if(a > b){ 
         c=a;
         a=b;
         b=c;
     } 
     for(c = a % b ; c > 0 ; c = a % b){ 
           a = b; 
           b = c; 
     } 
     denominator = denominator / b;
     numerator = numerator /b;
}

void fraction::reciprocal()
{
    int temp;
    temp = denominator;
    denominator = numerator;
    numerator = temp;     
}

int fraction::digit_number()
{
    return (count(numerator) + count(denominator));
}

fraction operator+(const fraction &a, const fraction &b) 
{
    fraction result;
    result.denominator = a.denominator * b.denominator;
    result.numerator = a.numerator * b.denominator + b.numerator * a.denominator;
    if ( result.denominator != 0 )
       result.simplify();
    return result;
}

fraction operator-(const fraction &a, const fraction &b)
{
    fraction result;
    result.denominator = a.denominator * b.denominator;
    result.numerator = a.numerator * b.denominator - b.numerator * a.denominator;
    if ( result.denominator != 0 )
       result.simplify();
    return result;    
}

fraction operator*(const fraction &a, const fraction &b)
{
    fraction result;
    result.denominator = a.denominator * b.denominator;
    result.numerator = a.numerator * b.numerator;
    if ( result.denominator != 0 )
       result.simplify();
    return result;     
}

fraction operator/(const fraction &a, fraction &b)
{
    b.reciprocal();
    return a*b; 
}

bool operator>(const fraction &a, const fraction &b)
{
    if ( a.numerator * b.denominator > b.numerator * a.denominator)
        return 1;
    else 
        return 0;    
}

bool operator<(const fraction &a, const fraction &b)
{
   if ( a.numerator * b.denominator < b.numerator * a.denominator)
        return 1;
   else 
        return 0;    
}

bool operator>=(const fraction &a, const fraction &b)
{
        return !( a < b );  
}

bool operator<=(const fraction &a, const fraction &b)
{
        return !( a > b);
}

bool operator==(const fraction &a, const fraction &b)
{
   if ( a.numerator * b.denominator == b.numerator * a.denominator )
        return 1;
   else 
        return 0;
}

bool operator!=(const fraction &a, const fraction &b)
{
        return !( a == b );     
}

ostream &operator<<( ostream &output, const fraction &a)
{
   return output << a.numerator << '/' << a.denominator;        
}

istream &operator>>( istream &input, fraction &a)
{
   return input >> a.numerator >> a.denominator;             
}
// override for class Integer
Integer::Integer(int a=0)
{
   set_numerator(a);
   set_denominator(1);
}

int Integer::digit_number()
{
   return count(get_numerator()); 
}

ostream &operator<<( ostream &output, Integer &a)
{
   return output << a.get_numerator();
}

int operator+( Integer &a, Integer &b) 
{
    int result;
    int aNumerator = a.get_numerator();
    int bNumerator = b.get_numerator();
    result = aNumerator + bNumerator;
    return result;
}

int operator-( Integer &a, Integer &b)
{
    int result;
    int aNumerator = a.get_numerator();
    int bNumerator = b.get_numerator();
    result = aNumerator - bNumerator;
    return result;
}

int operator*( Integer &a, Integer &b)
{
    int result;
    int aNumerator = a.get_numerator();
    int bNumerator = b.get_numerator();
    result = aNumerator * bNumerator;
    return result;
}

int operator/( Integer &a, Integer &b)
{
    int result;
    int aNumerator = a.get_numerator();
    int bNumerator = b.get_numerator();
    result = aNumerator / bNumerator;
    return result;
}