求高手解答，用C++设计一个有理数运算

#include
using namespace std;
//numerator 分子
//denominator分母
int gcd(int m,int n) //求最大公约数函数,用于约分
{
if(n==0)return m;
return gcd(n,m%n);
}
class fraction
{
private:
int numer;
int denom;
public:
fraction(int n=0,int d=1)//带默认参数的构造函数，整数与分数的运算迎刃而解
{
numer=n;
denom=d;
}
void rev(fraction &a){numer=a.denom;denom=a.numer;}//倒数
friend ostream& operator<<(std::ostream&, const fraction&); //重载输出
friend istream& operator>>(std::istream&, fraction&); //重载输入
friend bool operator==(const fraction&, const fraction&); //判断有理数是否相等，以下类似
friend bool operator<(const fraction&, const fraction&);
friend bool operator>(const fraction&, const fraction&);
friend bool operator>=(const fraction&, const fraction&);
friend bool operator<=(const fraction&, const fraction&);
friend fraction operator +(const fraction&,const fraction&);//重载运算符
friend fraction operator -(const fraction&,const fraction&);
friend fraction operator *(const fraction&,const fraction&);
friend fraction operator /(const fraction&,const fraction&);
friend bool operator!=(const fraction&, const fraction&);
};
fraction operator +(const fraction &a,const fraction &b)
{
fraction p;
p.numer=a.numer*b.denom+b.numer*a.denom;
p.denom=a.denom*b.denom;
return p;
}
fraction operator -(const fraction &a,const fraction &b)
{
fraction p;
p.numer=a.numer*b.denom-b.numer*a.denom;
p.denom=a.denom*b.denom;
return p;
}
fraction operator *(const fraction &a,const fraction &b)
{
fraction p;
p.numer=a.numer*b.numer;
p.denom=a.denom*b.denom;
return p;
}
fraction operator /(const fraction &a,const fraction &b)
{
fraction p;
p.numer=a.numer*b.denom;
p.denom=a.denom*b.numer;
return p;
}
ostream& operator<<(ostream& output,const fraction &num)
{
int a=gcd(num.numer,num.denom);
if((num.denom/a)==1)
output<else if(num.denom/a<0)
output<<-num.numer/a<<"/"<<-num.denom/a;
else output<return output;
}

istream& operator>>(istream&input, fraction& num)
{
input>>num.numer>>num.denom;
return input;
}
bool operator==(const fraction&num1, const fraction&num2)
{
return (num1.numer*num2.denom)==(num2.numer*num1.denom);
}
bool operator!=(const fraction &num1, const fraction &num2)
{
return (num1.numer*num2.denom)!=(num2.numer*num1.denom);
}

bool operator<(const fraction&a, const fraction&b)
{
return (a.numer*b.denom)<(b.numer*a.denom);
}
bool operator>(const fraction&a, const fraction&b)
{
return (a.numer*b.denom)>(b.numer*a.denom);
}
bool operator<=(const fraction&a, const fraction&b)
{
return (a.numer*b.denom)<=(b.numer*a.denom);
}
bool operator>=(const fraction&a, const fraction&b)
{
return (a.numer*b.denom)>=(b.numer*a.denom);
}
int main()
{
fraction zrf(1,7),ssh(26,65);
fraction p;
p.rev(ssh);
cout<<"ssh="<cout<<"zrf+ssh="<cout<<"zrf*ssh="<cout<<"ssh-zrf="<cout<<"zrf-ssh="<cout<<"zrf/ssh="<return 0;
}

/*
Name:
Copyright:
Author: goal00001111
Date: 08-01-09 11:31
Description:
问题描述
有理数是一个可以化为一个分数的数，例如2/3，533/920，-12/49都是有理数，否则就为无理数。在C++中，
并没有预先定义有理数，需要时可以定义一个有理数类，将有理数的分子和分母分别存放在两个整型变量中。
对有理数的各种操作都可以用重载运算符来实现。
基本要求
定义并实现一个有理数类，通过重载运算符+、-、*、/对有理数进行算术运算，
通过重载运算符==实现判定两个有理数是否相等。写一个优化函数，它的作用是使有理数约去公分母，
也即是使保存的有理数分子和分母之间没有公约数（除去1以外）。此外，还要定义一个将有理数转换为实数的函数，
再加上构造函数和有理数输出函数。
测试数据
在应用程序中，创建若干有理数对象，通过带参数的构造函数使得各有理数对象值各不相同，
然后分别进行各类运算，输出运算结果，检验其正确性。
实现提示
设有两个有理数a/b和c/d，则有：
有理数相加 分子=a*d+b*c；分母=b*d
有理数相减 分子=a*d-b*c；分母=b*d
有理数相乘 分子=a*c； 分母=b*d
有理数相除 分子=a*d； 分母=b*c
优化函数在创建有理数对象时应执行，在执行其它各种运算之后也需执行它，
这样可保证所存储的有理数随时都是最优的。对于判断两个有理数是否相等，
由于在对有理数进行各种运算后都对其进行优化，
所以判定两个有理数是否相等只需判定它们两个的分子和分母分别相等即可。
*/
#include
#include

using namespace std;

class RationalNumber{ //有理数类
public:
friend ostream & operator << (ostream & os, const RationalNumber & r);
friend bool operator == (const RationalNumber & r1, const RationalNumber & r2);
friend RationalNumber operator + (const RationalNumber & r1, const RationalNumber & r2);
friend RationalNumber operator - (const RationalNumber & r1, const RationalNumber & r2);
friend RationalNumber operator * (const RationalNumber & r1, const RationalNumber & r2);
friend RationalNumber operator / (const RationalNumber & r1, const RationalNumber & r2);

RationalNumber(int num = 0, int den = 1) : numerator(num), denominator(den) //构造函数
{
Divisor(); //约分
}

RationalNumber(const RationalNumber & r); //拷贝构造函数
RationalNumber & operator = (const RationalNumber & r); //赋值函数
int GetDenominator() { return denominator; } //返回分母
double RationalNumber::Realnumber() const ;

private:
int numerator; //分子
int denominator; //分母

int Gcd(int m, int n) //欧几里德算法求最大公约数
{
int t;
while (m > 0)
{
t = n % m;
n = m;
m = t;
}
return n;
}

void Divisor() //约分
{
int n = Gcd(numerator, denominator);
numerator /= n;
denominator /= n;
}
};

RationalNumber::RationalNumber(const RationalNumber & r) //拷贝构造函数
{
numerator = r.numerator;
denominator = r.denominator;
}

RationalNumber & RationalNumber::operator = (const RationalNumber & r) //赋值函数
{
if (this == &r) //检查自赋值
return *this;

numerator = r.numerator;
denominator = r.denominator;

return *this; //返回本对象的引用
}

//有理数转换为实数
double RationalNumber::Realnumber() const
{
return double(numerator) / double(denominator);
}

//重载条件运算符 ==
bool operator == (const RationalNumber & r1, const RationalNumber & r2)
{
return (r1.numerator == r2.numerator) &&
(r1.denominator == r2.denominator);
}

//重载输出运算符
ostream & operator << (ostream & os, const RationalNumber & r)
{
os << r.numerator << " / " << r.denominator;
return os;
}

RationalNumber operator + (const RationalNumber & r1, const RationalNumber & r2)
{
RationalNumber obj;
obj.numerator = r1.numerator * r2.denominator + r2.numerator * r1.denominator;
obj.denominator = r1.denominator * r2.denominator;

obj.Divisor();

return obj;
}
RationalNumber operator - (const RationalNumber & r1, const RationalNumber & r2)
{
RationalNumber obj;
obj.numerator = r1.numerator * r2.denominator - r2.numerator * r1.denominator;
obj.denominator = r1.denominator * r2.denominator;

obj.Divisor();

return obj;
}

RationalNumber operator * (const RationalNumber & r1, const RationalNumber & r2)
{
RationalNumber obj;
obj.numerator = r1.numerator * r2.numerator;
obj.denominator = r1.denominator * r2.denominator;

obj.Divisor();

return obj;
}

RationalNumber operator / (const RationalNumber & r1, const RationalNumber & r2)
{
RationalNumber obj;
obj.numerator = r1.numerator * r2.denominator;
obj.denominator = r2.denominator * r1.denominator;

obj.Divisor();

return obj;
}
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////

int main()
{
RationalNumber r1(2, 4);
RationalNumber r2(3, 12);

cout << r1 << endl;
cout << r2 << endl;

RationalNumber r3(r1);
cout << r3 << endl;

RationalNumber r4 = r1 + r2;
cout << r4 << endl;

cout << r4.Realnumber() << endl;

system("pause");
return 0;
}

对不起，我也不会。我们是一样的。

应该增加个约分的操作

原理与复数类一样的,复数类网上有现成的,你去找吧