分数类--运算符重载函数---完整版--gyy

/*
构造一个分数类Fraction,该类中包括分子和分母两个成员数据，并具有下述功能：
(1) 建立构造函数，它能防止分母为零，当分数不是最简形式时进行约分，并避免分母为负数。
(2) 重载加法、减法、乘法以及除法运算符。
(3) 重载关系运算符：>、>=、<、<=、==、!= 
(4) 重载插入">>"和提取"<<"运算符
(5) 重载自加"++"和自减"--"运算符
*/
#include<iostream.h>
#include<stdlib.h>
class Fraction
{
private:
	int numerator;  //分子 
    int denominator;  //分母

public:
    Fraction(int n=1,int d=1)  //形参n为分子赋值，形参d为分母赋值
	{  if(d==0)    // 如果分母为0，显示错误信息,退出程序
		{cout<<"error!,the denominator is not equal to 0!"<<endl<<"exit program......"<<endl; 
		 exit(1); //退出程序
		}
       else if(d<0) //  如果分母为负，进行转换，分子分母同时乘以-1，得到分母为正，分子为相反数
	   { n=(-1)*n;
	     d=(-1)*d;
	   }
        numerator=n;
		denominator=d;
	}

	void simple()  //对原始分数进行化简，在不是最简形式时进行约分
	{
		int k;
		k=numerator<denominator?numerator:denominator;
		for(int i=2;i<=k;i++)
		{   while(( numerator%i==0)&&(denominator%i==0))   //分子分母如果同时是i的倍数时，进行化简
			{ numerator= numerator/i;
		      denominator=denominator/i;
			}
		}
	}


	void disp() //分数显示
	{ if(numerator==0)
		{cout<<"0"<<endl;
	     return;
		}
	  else if (numerator==denominator) 
		{cout<<"1"<<endl;
	     return;
		}
	  cout<<numerator<<"/"<<denominator<<endl;
	}

	void set_numerator() //输入分子
	{
	  cin>>numerator;
	}

	int get_numerator() //获取分子
	{
	  return numerator;
	}

    void set_denominator() //输入分母
	{
	    int d;
		cin>>d;
		if(d!=0)
		denominator=d;
		else
		{
		 cout<<"error!,the denominator is not equal to 0!"<<endl<<"exit program......"<<endl; 
		 exit(1); //退出程序
		}
	}

	int get_denominator()  //获取分母
	{
	  return  denominator;
	}

    Fraction operator ++(); //成员函数进行"++"运算符重载，作为前置运算符
	Fraction operator ++(int);  //成员函数进行"++"运算符重载，作为后置运算符
	Fraction operator --();   //成员函数进行"--"运算符重载，作为前置运算符
	Fraction operator --(int);  //成员函数进行"--"运算符重载，作为前置运算符

	friend Fraction operator +(Fraction a,Fraction b);  //友元函数进行"+"运算符重载，进行分数相加
	friend Fraction operator -(Fraction a,Fraction b);  //友元函数进行"-"运算符重载，进行分数相减
	friend Fraction operator *(Fraction a,Fraction b);  //友元函数进行"*"运算符重载，进行分数相乘
	friend Fraction operator /(Fraction a,Fraction b);  //友元函数进行"+"运算符重载，进行分数相除
	friend Fraction operator -(Fraction a);  //友元函数进行"-"运算符重载，进行分数求相反数

	friend int operator > (Fraction a,Fraction b);   //友元函数进行">"运算符重载，进行分数比较
	friend int operator >=(Fraction a,Fraction b);  //友元函数进行">="运算符重载，进行分数比较
	friend int operator < (Fraction a,Fraction b);   //友元函数进行"<"运算符重载，进行分数比较
	friend int operator <=(Fraction a,Fraction b);  //友元函数进行"<="运算符重载，进行分数比较
	friend bool operator ==(Fraction a,Fraction b); //友元函数进行"=="运算符重载，进行分数比较
	friend bool operator !=(Fraction a,Fraction b); //友元函数进行"!="运算符重载，进行分数比较

	friend ostream & operator<<(ostream & output,Fraction & f ); //友元函数进行"<<"运算符重载，进行分数类对象的输出
	friend istream & operator>>(istream & input,Fraction & f );  //友元函数进行">>"运算符重载，进行分数类对象的输入

};

Fraction Fraction::operator ++() //成员函数进行"++"运算符重载，作为前置运算符,返回的是已改变值之后的对象
{
  numerator=numerator+denominator;
  return (* this); //返回自加后的对象
}

Fraction Fraction::operator ++(int) //成员函数进行"++"运算符重载，作为后置运算符，返回的是改变值之前的对象
{
  Fraction temp=(*this);
  numerator=numerator+denominator;
  return temp;  //返回自加前的对象
}

Fraction Fraction::operator --()  //成员函数进行"--"运算符重载，作为前置运算符，返回的是已改变值之后的对象
{
  numerator=numerator-denominator;
  return (* this); //返回自减后的对象
}

Fraction Fraction::operator --(int)  //成员函数进行"--"运算符重载，作为前置运算符，返回的是改变值之前的对象
{
  Fraction temp=(*this);
  numerator=numerator-denominator;
  return temp;  //返回自减前的对象
}


Fraction operator + (Fraction a,Fraction b)
{   Fraction temp;
	temp.numerator=(a.numerator*b.denominator)+b.numerator*a.denominator;
	temp.denominator=a.denominator*b.denominator;
	temp.simple();
	return temp;
}

Fraction operator -(Fraction a,Fraction b)
{   Fraction temp;
	temp.numerator=(a.numerator*b.denominator)-b.numerator*a.denominator;
	temp.denominator=a.denominator*b.denominator;
	temp.simple();
	return temp;
}

Fraction operator -(Fraction a)
{   Fraction temp;
	temp.numerator=a.numerator*(-1);
	temp.denominator=a.denominator;
	temp.simple();
	return temp;
}

Fraction operator *(Fraction a,Fraction b)
{   Fraction temp;
	temp.numerator=a.numerator*b.numerator;
	temp.denominator=a.denominator*b.denominator;
	temp.simple();
	return temp;
}
Fraction operator /(Fraction a,Fraction b)
{   Fraction temp;
	temp.numerator=a.numerator*b.denominator;
	temp.denominator=a.denominator*b.numerator;
	temp.simple();
	return temp;
}

int operator >(Fraction a,Fraction b)
{return (float)a.numerator/(float)a.denominator>(float)b.numerator/(float)b.denominator;}

int operator >=(Fraction a,Fraction b)
{return (float)a.numerator/(float)a.denominator>=(float)b.numerator/(float)b.denominator;}

int operator <(Fraction a,Fraction b)
{return (float)a.numerator/(float)a.denominator<(float)b.numerator/(float)b.denominator;}

int operator <=(Fraction a,Fraction b)
{return (float)a.numerator/(float)a.denominator<=(float)b.numerator/(float)b.denominator;}

bool operator ==(Fraction a,Fraction b)
{return a.numerator*b.denominator==b.numerator*a.denominator;}

bool operator !=(Fraction a,Fraction b)
{return a.numerator*b.denominator!=b.numerator*a.denominator;}

ostream & operator<<(ostream & output,Fraction & f )
{
   if(f.numerator==0)
		{output<<"0"<<endl;
	     return output;
		}
	  else if (f.numerator==f.denominator) 
		{output<<"1"<<endl;
	     return output;
		}
	  output<<f.numerator<<"/"<<f.denominator<<endl;
	  return output;
}

istream & operator>>(istream & input,Fraction & f )
{
	cout<<"input the numerator of fraction: "<<endl; 
    input>>f.numerator;
	cout<<"input the  denominator of fraction: "<<endl; 
    input>>f.denominator;
	return input;
}

int main ()
{
	Fraction p1(3,5),p2(12,16),p3;   //定义Fraction类对象
	cout<<"p1=";
	p1.disp();    //显示p1的值
	p1.simple( );  //对p1进行化简
	cout<<"after simple"<<'\t';
	cout<<"p1=";
	p1.disp();    //显示p1的值
	cout<<"p2=";
	p2.disp();     //显示p2的值
	p2.simple( );  //对p2进行化简
	cout<<"after simple"<<'\t';
	cout<<"p2=";  
	p2.disp();  //显示p2的值
	p3=p1+p2;    //调用+运算符重载函数进行2个Fraction对象的相加
	cout<<"p1+p2=";
	p3.disp();
	p3=p1-p2;    //调用-运算符重载函数进行2个Fraction对象的相减
	cout<<"p1-p2=";  
	p3.disp();
	p3=p1*p2;   //调用*运算符重载函数进行2个Fraction对象的相乘
	cout<<"p1*p2=";
	p3.disp();
	p3=p1/p2;   //调用/运算符重载函数进行2个Fraction对象的相除
	cout<<"p1/p2=";
	p3.disp(); 
	p3=-p1;    //调用-运算符重载函数进行1个Fraction对象的求反
	cout<<"-p1=";
	p3.disp();

	if(p1==p2)   //调用==运算符重载函数进行2个Fraction对象的相等比较
		cout<<"p1=p2"<<endl;
    if(p1!=p2)   //调用!=运算符重载函数进行2个Fraction对象的不相等比较
		cout<<"p1!=p2"<<endl;
	if(p1>p2)   //调用>运算符重载函数进行2个Fraction对象的大于比较
		cout<<"p1>p2"<<endl;
	if(p1>=p2)   //调用>=运算符重载函数进行2个Fraction对象的大于等于比较
        cout<<"p1>=p2"<<endl;
	if(p1<p2)    //调用<运算符重载函数进行2个Fraction对象的小于比较
		cout<<"p1<p2"<<endl;
	if(p1<=p2)   //调用<=运算符重载函数进行2个Fraction对象的小于等于比较
		cout<<"p1<=p2"<<endl;

	p3=p1++;  //调用后自增运算符重载函数
	cout<<"p3=p1++"<<endl;
	cout<<"p1=";
	p1.disp();
	cout<<"p3=";
	p3.disp();

	p3=p1--;   //调用后自减运算符重载函数
	cout<<"p3=p1--"<<endl;
	cout<<"p1=";
	p1.disp();
	cout<<"p3=";
	p3.disp();

    p3=++p2;   //调用前自增运算符重载函数
	cout<<"p3=++p2"<<endl;
	cout<<"p2=";
	p2.disp();
	cout<<"p3=";
	p3.disp();

    p3=--p2; //调用前自减运算符重载函数
	cout<<"p3=--p2"<<endl;
	cout<<"p2=";
	p2.disp();
	cout<<"p3=";
	p3.disp();
    
	cout<<endl<<endl;
    
	//利用成员函数重新为分数类对象各个成员赋值
	cout<<"input the numerator and denominator of p1 :";
	p1.set_numerator();  //为p1的分子赋值
	p1.set_denominator();  //为p1的分母赋值
	cout<<"p1=";
	p1.disp();  //显示p1的值
	p1.simple();  //对p1进行化简
    cout<<"after simple"<<'\t';
	cout<<"p1="; 
    p1.disp();  //显示p1的值
    cout<<"input the numerator and denominator of p2 :";
	p2.set_numerator();   //为p2的分子赋值
	p2.set_denominator();   //为p2的分母赋值
	cout<<"p2=";
	p2.disp();  //显示p2的值
	p2.simple();  //对p2进行化简
    cout<<"after simple"<<'\t';
	cout<<"p2=";
    p2.disp();   //显示p2的值 
    p3=p1+p2; 
	cout<<"p1+p2=";
	p3.disp();
	p3=p1-p2;
	cout<<"p1-p2=";
	p3.disp();
	p3=p1*p2; 
	cout<<"p1*p2=";
	p3.disp();
	p3=p1/p2; 
	cout<<"p1/p2=";
	p3.disp();
	p3=-p1;
	cout<<"-p1=";
	p3.disp();
	if(p1==p2) 
		cout<<"p1=p2"<<endl;
    if(p1!=p2) 
		cout<<"p1!=p2"<<endl;
	if(p1>p2)
		cout<<"p1>p2"<<endl;
	if(p1>=p2)
        cout<<"p1>=p2"<<endl;
	if(p1<p2) 
		cout<<"p1<p2"<<endl;
	if(p1<=p2) 
		cout<<"p1<=p2"<<endl; 
	cout<<endl<<endl;

	//通过<<和>>运算符重载进行Fraction类对象的输入和输出
	cout<<"input p1"<<endl;
	cin>>p1;  //利用>>运算符重载函数进行p1对象的输入
	cout<<"p1="<<p1;  //利用<<运算符重载函数进行p1对象的输出
	p1.simple();   //对p2进行化简
	cout<<"after simple"<<'\t';
	cout<<"p1="<<p1;   //利用<<运算符重载函数进行p1对象的输出
    cout<<"input p2"<<endl;
	cin>>p2;   //利用>>运算符重载函数进行p2对象的输入
	cout<<"p2="<<p2;  //利用<<运算符重载函数进行p2对象的输出
	p2.simple();   //对p2进行化简
	cout<<"after simple"<<'\t';
	cout<<"p2="<<p2;  //利用<<运算符重载函数进行p2对象的输出
	
	return 0;
	
}