fraction

 this assignment you are required to complete a class for fractions.

It stores the numerator and the denominator, with the lowest terms.

It is able to communicate with iostreams by the operator << and >>.

For more details, read the header file.

Sample Input

1 0 2 3
Sample Output

NaN NaN NaN NaN
NaN
False
True
False
False
True
True
Hint:

如果分母为0，那么进行四则运算时返回一个0/0.

==操作符 相等的情况是 两个数分母都为0或者两个数本身相等。

<的操作就按正常的比较即可。

main函数

void print(const bool & f) {
    if (f)
        std::cout << "True" << std::endl;
    else
        std::cout << "False" << std::endl;
}

int main() {
    fraction f1, f2;
    std::cin >> f1 >> f2;
    std::cout << f1 + f2 << ' ' << f1 - f2 << ' '
              << f1 * f2 << ' ' << f1 / f2 << std::endl;
    f1 += f2;
    f1 -= f2;
    f1 *= f2;
    f1 /= f2;
    std::cout << f1 << std::endl;
    print(f1 == f2);
    print(f1 != f2);
    print(f1 < f2);
    print(f1 > f2);
    print(f1 <= f2);
    print(f1 >= f2);
    return 0;
}

.h文件

#include <iostream>

class fraction {
    private:
        int _numerator, _denominator;
        int gcd(const int &, const int &) const;
            // If you don't need this method, just ignore it.
        void simp();
            // To get the lowest terms.
    public:
        fraction(const int & = 0, const int & = 1);
            // The numerator and the denominator
            // fraction(5) = 5/1 = 5 :)
        fraction(const fraction &);
            // copy constructor

        void operator=(const fraction &);

        // You must know the meaning of +-*/, don't you ?
        fraction operator+(const fraction &) const;
        fraction operator-(const fraction &) const;
        fraction operator*(const fraction &) const;
        fraction operator/(const fraction &) const;

        void operator+=(const fraction &);
        void operator-=(const fraction &);
        void operator*=(const fraction &);
        void operator/=(const fraction &);

        // Comparison operators
        bool operator==(const fraction &) const;
        bool operator!=(const fraction &) const;
        bool operator<(const fraction &) const;
        bool operator>(const fraction &) const;
        bool operator<=(const fraction &) const;
        bool operator>=(const fraction &) const;

        friend std::istream & operator>>(std::istream &, fraction &);
            // Input Format: two integers with a space in it
            // "a b" is correct. Not "a/b"
        friend std::ostream & operator<<(std::ostream &, const fraction &);
            // Normally you should output "a/b" without any space and LF
            // Sometims you may output a single integer (Why? Guess XD)
            // If it is not a number (den = 0), output "NaN"
};

解答

long long mgcd( long long a,long long b)
{
    long long i;
    if (b==0)
        i=a;
    else
        i=mgcd(b,a%b);
    return i;
}
// If you don't need this method, just ignore it.
void fraction::simp()
{
    _numerator/=mgcd(_numerator,_denominator);
    _denominator/=mgcd(_numerator,_denominator);
}
// To get the lowest terms.
fraction::fraction(const int&a,const int&b):_numerator(a),_denominator(b)
{
}
// The numerator and the denominator
// fraction(5) = 5/1 = 5 :)
fraction::fraction(const fraction &a)
{
    _numerator=a._numerator;
    _denominator=a._denominator;
}
// copy constructor

void fraction::operator=(const fraction &a)
{
    this->_denominator=a._denominator;
    this->_numerator=a._numerator;
}

// You must know the meaning of +-*/, don't you ?
fraction fraction::operator+(const fraction &t)const
{
    fraction temp;
    long long a=_denominator;
    long long c=_numerator;
    long long b=t._denominator;
    long long d=t._numerator;
    long long m=mgcd(a*b, b*c+a*d);

    temp._denominator=(int)(a*b/m);
    temp._numerator=(int)((b*c+a*d)/m);
    return temp;
}
fraction fraction::operator-(const fraction &t) const
{
    fraction temp;
    long long a=_denominator;
    long long c=_numerator;
    long long b=t._denominator;
    long long d=t._numerator;
    long long m=mgcd(a*b, b*c-a*d);

    temp._denominator=(int)(a*b/m);
    temp._numerator=(int)((b*c-a*d)/m);
    return temp;
}
fraction fraction::operator*(const fraction &t) const
{
    fraction temp;
    long long a=_denominator;
    long long c=_numerator;
    long long b=t._denominator;
    long long d=t._numerator;
    long long m=mgcd(a*b, c*d);

    temp._denominator=(int)(a*b/m);
    temp._numerator=(int)((c*d)/m);
    return temp;
}
fraction fraction::operator/(const fraction &t) const
{
    fraction temp;
    long long a=_denominator;
    long long c=_numerator;
    long long b=t._denominator;
    long long d=t._numerator;
    long long m=mgcd(a*d, c*b);

    temp._denominator=(int)(a*d/m);
    temp._numerator=(int)((c*b)/m);
    return temp;
}

void fraction::operator+=(const fraction &a)
{
    (*this)=(*this)+a;
}
void fraction::operator-=(const fraction &a)
{
    (*this)=(*this)-a;
}
void fraction::operator*=(const fraction &a)
{
    (*this)=(*this)*a;
}
void fraction::operator/=(const fraction &a)
{
    (*this)=(*this)/a;
}

// Comparison operators
bool fraction::operator==(const fraction &a) const
{
    fraction temp1(*this),temp2(a);
    temp1.simp();
    temp2.simp();
    if((temp1._denominator==temp2._denominator&&temp1._numerator==temp2._numerator)||(temp1._denominator==0&&temp2._denominator==0))
        return true;
    return false;
}
bool fraction::operator!=(const fraction &a) const
{
    if((*this)==a)
        return false;
    return true;
}
bool fraction::operator<(const fraction &a) const
{
    double m=a._numerator*1.0/a._denominator;
    double n=_numerator*1.0/_denominator;
    if(n<m)
        return true;
    return false;
}
bool fraction::operator>(const fraction &a) const
{
    if((*this)<a||(*this)==a)
        return false;
    return true;
}
bool fraction::operator<=(const fraction &a) const
{
    if((*this)<a||(*this)==a)
        return true;
    return false;
}
bool fraction::operator>=(const fraction &a) const
{
    if((*this)>a||(*this)==a)
        return true;
    return false;
}

 std:: istream &operator>>(std::istream &in, fraction &a)
{
    in>>a._numerator>>a._denominator;
    return in;
}
// Input Format: two integers with a space in it
// "a b" is correct. Not "a/b"
 std::ostream & operator<<(std::ostream &out, const fraction &a)
{
    if((a._numerator<0&&a._denominator>0)||(a._numerator>0&&a._denominator<0))
        out<<'-'<<abs(a._numerator)<<'/'<<abs(a._denominator);
    else
        out<<abs(a._numerator)<<'/'<<abs(a._denominator);
    return out;

心得：
（1）

fraction fraction::operator+(const fraction &t)const
{
    fraction temp;
    long long a=_denominator;
    long long c=_numerator;
    long long b=t._denominator;
    long long d=t._numerator;
    long long m=mgcd(a*b, b*c+a*d);

    temp._denominator=(int)(a*b/m);
    temp._numerator=(int)((b*c+a*d)/m);
    return temp;
}

这样写的目的主要是为了避免溢出的情况。