c++有理数类代码

本程序的作用

1.有理数的构造方法

2.有理数与有理数的四则运算

3.有理数的约分

4.有理数与double浮点数的四则运算

5.有理数与整型数int的四则运算

6.有理数的赋值运算，重载=运算符

7.有理数的输入cin>>

8.有理数的输出cout<<

9.测试程序

话不多说，直接上代码

Rational.h

#ifndef RATIONAL_H
#define RATIONAL_H
#include <iostream>

using namespace std;

class Rational
{
private:
    int fenzi, fenmu;
    void simply();//化简
    bool negative() const;//判断是否是负数
public:
    Rational(int numerator = 0, int denominator = 1);//构造函数
    Rational(const double n);//类型转换构造函数
    Rational(const Rational& ra);//复制构造函数
    //~Rational();没有动态分配，默认析构就行

    Rational& operator =(const Rational& ra);
    Rational& operator =(const double& n);//使有理数类对象能被double类型赋值

    //以下20个函数使有理数类对象能和double类型混合加减乘除和赋值
    Rational operator +(const Rational& ra);
    Rational operator -(const Rational& ra);
    Rational operator *(const Rational& ra);
    Rational operator /(const Rational& ra);
    friend Rational operator +(const double& n, const Rational& ra);
    friend Rational operator -(const double& n, const Rational& ra);
    friend Rational operator *(const double& n, const Rational& ra);
    friend Rational operator /(const double& n, const Rational& ra);
    Rational& operator +=(const Rational& ra);
    Rational& operator -=(const Rational& ra);
    Rational& operator *=(const Rational& ra);
    Rational& operator /=(const Rational& ra);

    Rational operator +(const double& n);
    Rational operator -(const double& n);
    Rational operator *(const double& n);
    Rational operator /(const double& n);
    Rational& operator +=(const double& n);
    Rational& operator -=(const double& n);
    Rational& operator *=(const double& n);
    Rational& operator /=(const double& n);
    // 有理数与整数int的计算
    Rational operator +(const int& n);
    Rational operator -(const int& n);
    Rational operator *(const int& n);
    Rational operator /(const int& n);
    friend Rational operator +(const int& n, const Rational& ra);
    friend Rational operator -(const int& n, const Rational& ra);
    friend Rational operator *(const int& n, const Rational& ra);
    friend Rational operator /(const int& n, const Rational& ra);
    Rational operator +=(const int& n);
    Rational operator -=(const int& n);
    Rational operator *=(const int& n);
    Rational operator /=(const int& n);

    int GetFenzi() { return fenzi; }
    int GetFenmu() { return fenmu; }
    void Set(int numerator, int denominator) { fenzi = numerator; fenmu = denominator; }

    //重载强制类型转换运算符，使得凡是应该出现double型的地方，均可以由有理数类对象替代。比如，可以使得
    //有理数类对象和普通double型比较大小成为可能
    operator double();

    //支持以m/n形式的有理数类对象输入输出,负号会显示在前面。
    friend ostream& operator <<(ostream& os, const Rational& ra);
    friend istream& operator >>(istream& is, Rational& ra);
};

#endif

Rational.cpp

#include <iostream>
#include <string>
#include <cstdlib>
#include "Rational.h"

using namespace std;
// 约分
void Rational::simply()//辗转相除法求最大公约数化简
{
	int a = fenzi, b = fenmu;
	while (b) {
		int mod = a % b;
		a = b;
		b = mod;
	}

	fenzi /= a;
	fenmu /= a;
}
// 是否为负数<0
bool Rational::negative() const
{
	return (fenzi < 0 || fenmu < 0);
}
// 构造方法
Rational::Rational(int numerator, int denominator)
{
	fenzi = numerator;
	fenmu = denominator;
	simply();//确保任意路径得到的有理数类对象均是最简形式
}
Rational::Rational(const double n)
{
	double numerator = n, denominator = 1;

	while ((int)numerator != numerator) {
		numerator *= 10;
		denominator *= 10;
	}

	fenzi = numerator, fenmu = denominator;
	simply();//确保任意路径得到的有理数类对象均是最简形式
}
// 拷贝方法
Rational::Rational(const Rational& ra) : fenzi(ra.fenzi), fenmu(ra.fenmu) {}
// 重载赋值运算符=
Rational& Rational::operator =(const Rational& ra)
{
	fenzi = ra.fenzi, fenmu = ra.fenmu;
	return *this;
}
Rational& Rational::operator =(const double& n)
{
	Rational tmp(n);
	*this = tmp;
	return *this;
}
// 有理数与有理数的运算+-*/
Rational Rational::operator +(const Rational& ra)
{
	int numerator = fenzi * ra.fenmu + ra.fenzi * fenmu;
	int denominator = fenmu * ra.fenmu;

	return Rational(numerator, denominator);
}
Rational Rational::operator -(const Rational& ra)
{
	int numerator = fenzi * ra.fenmu - ra.fenzi * fenmu;
	int denominator = fenmu * ra.fenmu;

	return Rational(numerator, denominator);
}
Rational Rational::operator *(const Rational& ra)
{
	int numerator = fenzi * ra.fenzi;
	int denominator = fenmu * ra.fenmu;

	return Rational(numerator, denominator);
}
Rational Rational::operator /(const Rational& ra)
{
	if (ra.fenzi == 0) {
		// 抛出异常
		throw exception("除数为0了！");
		cout << "除数为0了！" << endl;
		exit(1);
	}
	int numerator = fenzi * ra.fenmu;
	int denominator = fenmu * ra.fenzi;

	return Rational(numerator, denominator);
}
Rational& Rational::operator +=(const Rational& ra)
{
	Rational tmp = *this + ra;
	*this = tmp;
	return *this;
}
Rational& Rational::operator -=(const Rational& ra)
{
	Rational tmp = *this - ra;
	*this = tmp;
	return *this;
}
Rational& Rational::operator *=(const Rational& ra)
{
	Rational tmp = *this * ra;
	*this = tmp;
	return *this;
}
Rational& Rational::operator /=(const Rational& ra)
{
	Rational tmp = *this / ra;
	*this = tmp;
	return *this;
}
// 重载double浮点数与有理数的运算+-*/
Rational Rational::operator +(const double& n)
{
	Rational tmp(n);
	return *this + tmp;
}
Rational Rational::operator -(const double& n)
{
	Rational tmp(n);
	return *this - tmp;
}
Rational Rational::operator *(const double& n)
{
	Rational tmp(n);
	return *this * tmp;
}
Rational Rational::operator /(const double& n)
{
	Rational tmp(n);
	return *this / tmp;
}
Rational operator +(const double& n, const Rational& ra)
{
	Rational tmp(n);
	return tmp + ra;
}
Rational operator -(const double& n, const Rational& ra)
{
	Rational tmp(n);
	return tmp - ra;
}
Rational operator *(const double& n, const Rational& ra)
{
	Rational tmp(n);
	return tmp * ra;
}
Rational operator /(const double& n, const Rational& ra)
{
	Rational tmp(n);
	return tmp / ra;
}
Rational& Rational::operator +=(const double& ra)
{
	Rational tmp(ra);
	*this += tmp;
	return *this;
}
Rational& Rational::operator -=(const double& ra)
{
	Rational tmp(ra);
	*this -= tmp;
	return *this;
}
Rational& Rational::operator *=(const double& ra)
{
	Rational tmp(ra);
	*this *= tmp;
	return *this;
}
Rational& Rational::operator /=(const double& ra)
{
	Rational tmp(ra);
	*this /= tmp;
	return *this;
}
// 有理数转化为浮点数
Rational::operator double()
{
	return (double)fenzi / fenmu;
}
// 有理数与整数int的计算+-*/
Rational Rational::operator +(const int& n) {
	Rational tmp((double)n);
	return *this + tmp;
}
Rational Rational::operator -(const int& n) {
	Rational tmp((double)n);
	return *this - tmp;
}
Rational Rational::operator *(const int& n) {
	Rational tmp((double)n);
	return *this * tmp;
}
Rational Rational::operator /(const int& n) {
	Rational tmp((double)n);
	return *this / tmp;
}
Rational operator +(const int& n, const Rational& ra) {
	Rational tmp((double)n);
	return tmp + ra;
}
Rational operator -(const int& n, const Rational& ra) {
	Rational tmp((double)n);
	return tmp - ra;
}
Rational operator *(const int& n, const Rational& ra) {
	Rational tmp((double)n);
	return tmp * ra;
}
Rational operator /(const int& n, const Rational& ra) {
	Rational tmp((double)n);
	return tmp / ra;
}
Rational Rational::operator +=(const int& n) {
	Rational tmp((double)n);
	*this += tmp;
	return *this;
}
Rational Rational::operator -=(const int& n) {
	Rational tmp((double)n);
	*this -= tmp;
	return *this;
}
Rational Rational::operator *=(const int& n) {
	Rational tmp((double)n);
	*this *= tmp;
	return *this;
}
Rational Rational::operator /=(const int& n) {
	Rational tmp((double)n);
	*this /= tmp;
	return *this;
}
// 重写cout<<Rational输出方法
ostream& operator <<(ostream& os, const Rational& ra)
{
	if (ra.fenzi == 0)
		os << 0;
	else if (ra.negative())
		if (abs(ra.fenmu) == 1)
			os << "-" << abs(ra.fenzi);
		else
			os << "-" << abs(ra.fenzi) << "/" << abs(ra.fenmu); //如果是负数，符号写在前面。
	else
		if (abs(ra.fenmu) == 1)
			os << ra.fenzi;
		else
			os << ra.fenzi << "/" << ra.fenmu;
	return os;
}
// 重写cin>>Rational输入方法
istream& operator >>(istream& is, Rational& ra)
{
	string s;
	is >> s;

	int pos = s.find("/", 0);

	string sTmp = s.substr(0, pos);
	ra.fenzi = atoi(sTmp.c_str());//读入分子
	sTmp = s.substr(pos + 1, s.length() - pos - 1);
	ra.fenmu = atoi(sTmp.c_str());//读入分母

	return is;
}

RationalTest.cpp

#include <iostream>
#include "Rational.h"
using namespace std;

int main()
{
	// 有理数测试
	Rational r1(1.5);
	Rational r2(7.5);
	cout << r1 + 1 << endl;
	cout << r1 - 1 << endl;
	cout << r1 * -2 << endl;
	cout << r1 / 2 << endl;

	cout << r1 + r2 << endl;
	cout << r1 - r2 << endl;
	cout << r1 * r2 << endl;
	cout << r1 / r2 << endl;
	return 0;
}