C++实现分数类

最新推荐文章于 2024-09-23 20:17:41 发布
最新推荐文章于 2024-09-23 20:17:41 发布
阅读量9.2k 收藏 25
点赞数
分类专栏： 数学系列 文章标签： 分数 类 数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41461277/article/details/84890580
版权

在几乎所有的语言中（至少我知道的语言都是这样），浮点数都是有精度丢失的。

怎么解决呢？

分数类就是解决办法之一。

        分数类采用分数的形式，保存了两个整数之比，确保了精度。

        分数类，肯定是要有约分、通分等函数和加、减、乘、除运算符的。（当然，要先实现求最大公因数和最小公倍数函数）这些都是基本数学知识。

        代码如下：

#ifndef FRACTION_H
#define FRACTION_H
#include<iostream>
#include<cstdio>
using std::istream;
using std::ostream;
using std::getchar;
namespace math{
	template<typename T>
	T gcd(T x,T y){
		if(x<y){
			int temp=x;
			x=y,y=temp;
		}
		int z;
		while(y!=0){
			z=x%y,x=y,y=z;
		}
		return x;
	}
	template<typename T>
	T lcm(T x,T y){
		return x/gcd(x,y)*y;
	} 
}
template<typename T,typename Tvalue=double>  //T==int,long long,your big_int class ......
class fraction{
	private:
	T _up,_down;
	bool input_with_reduction,output_with_reduction,multi_optimize;
			//optimize指上界优化，即：以牺牲时间为代价换取不溢出 
	public:
	// constructors
	fraction(){
		_up=1,_down=1,input_with_reduction=output_with_reduction=1,multi_optimize=0;
	}
	fraction(T up,T down){
		_up=up,_down=down,input_with_reduction=output_with_reduction=1,multi_optimize=0;
		if(input_with_reduction) reduction();
	}
	fraction(bool optimize){
		_up=1,_down=1,input_with_reduction=output_with_reduction=1,multi_optimize=optimize;
	}
	fraction(T up,T down,bool optimize){
		_up=up,_down=down,input_with_reduction=output_with_reduction=1,multi_optimize=optimize;
		if(input_with_reduction) reduction();
	}
	fraction(bool input_reduct,bool output_reduct){
		_up=1,_down=1,input_with_reduction=input_reduct,output_with_reduction=output_reduct,
			multi_optimize=0;
	}
	fraction(T up,T down,bool input_reduct,bool output_reduct){
		_up=up,_down=down,input_with_reduction=input_reduct,output_with_reduction=output_reduct,
			multi_optimize=0;
		if(input_with_reduction) reduction();
	}
	fraction(bool input_reduct,bool output_reduct,bool optimize){
		_up=1,_down=1,input_with_reduction=input_reduct,output_with_reduction=output_reduct,
			multi_optimize=optimize;
	}
	fraction(T up,T down,bool input_reduct,bool output_reduct,bool optimize){
		_up=up,_down=down,input_with_reduction=input_reduct,output_with_reduction=output_reduct,
			multi_optimize=optimize;
		if(input_with_reduction) reduction();
	}
	// inputs
	friend istream& operator >> (istream& input,fraction<T>& the_frac){
		if(the_frac.input_with_reduction) the_frac.reduction();
		input>>the_frac._up;
		getchar();
		input>>the_frac._down;
		return input;
	}
	fraction<T> input_cin(bool with_reduction=1){
		if(with_reduction) reduction();
		using std::cin;
		cin>>_up;
		getchar();
		cin>>_down;
		return *this;
	}
	// outputs
	friend ostream& operator << (ostream& output,fraction<T> the_frac){
		if(the_frac.output_with_reduction) the_frac.reduction();
		output<<the_frac._up<<'/'<<the_frac._down;
		return output;
	}
	fraction<T> output_cout(bool with_reduction=1){
		if(with_reduction) reduction();
		using std::cout;
		cout<<_up<<'/'<<_down;
		return *this;
	}
	// basic_functions
	T up(){
		return _up;
	}
	T down(){
		return _down;
	}
	// (bool change)
	bool input_reduction(bool change_to){
		input_with_reduction=change_to;
		return change_to;
	}
	bool output_reduction(bool change_to){
		output_with_reduction=change_to;
		return change_to;
	}
	bool multi_optimize_change(bool change_to){
		multi_optimize=change_to;
		return change_to;
	}
	bool all_reduction(bool input_change_to,bool output_change_to){
		input_with_reduction=input_change_to,output_with_reduction=output_change_to;
		return input_change_to&&output_change_to;
	}
	bool all_bool_change(bool input_change_to,bool output_change_to,bool optimize_change_to){
		input_with_reduction=input_change_to,output_with_reduction=output_change_to,
			multi_optimize=optimize_change_to;
		return (input_change_to&&output_change_to)^optimize_change_to;
	}
	// (end of bool change)
	template<typename Tans=Tvalue>
	Tans value()const{
		return Tans(_up)/Tans(_down);
	}
	fraction<T> reduction(){  //约分 
		T gcd_result=math::gcd(_up,_down);
		_up/=gcd_result,_down/=gcd_result;
		return *this;
	}
	fraction<T> reciprocal(bool with_reduction=1)const{
		return fraction<T>(_down,_up,with_reduction,1);
	}
	template<typename T1,typename T2=T1>
	static void common(fraction<T1> &frac_x,fraction<T2> &frac_y){  //通分 
		T gcd_num=math::gcd(frac_x._down,frac_y._down);
		T1 x_multi_num=frac_y._down/gcd_num,y_multi_num=frac_x._down/gcd_num;
		frac_x._down*=x_multi_num,frac_x._up*=x_multi_num;
		frac_y._down*=y_multi_num,frac_y._up*=y_multi_num;
	}
	operator Tvalue()const{
		return Tvalue(_up)/Tvalue(_down);
	}
	// operator + , - , * , /
	// operator +
	fraction<T> operator + (T another_adder)const{
		fraction<T> frac_adder(another_adder*_down,_down,0,0);
		return fraction<T>(_up+frac_adder._up,_down,1,1);
	}
	fraction<T> operator + (fraction<T> another_adder)const{
		two_fracs<T> commoned=common_value(*this,another_adder);
		return fraction<T>(commoned.first._up+commoned.second._up,commoned.first._down,true,true);
	}
	friend fraction<T> operator + (T adder,fraction<T> frac_adder){
		fraction<T> frac_adder_eq1(adder*frac_adder._down,frac_adder._down,false,false);
		return fraction<T>(frac_adder._up+frac_adder_eq1._up,frac_adder._down,true,true);
	}
	//operator -
	fraction<T> operator - (fraction<T> another_adder)const{
		two_fracs<T> commoned=common_value(*this,another_adder);
		return fraction<T>(commoned.first._up-commoned.second._up,commoned.first._down,true,true);
	}
	friend fraction<T> operator - (T adder,fraction<T> frac_adder){
		fraction<T> frac_adder_eq1(adder*frac_adder._down,frac_adder._down,false,false);
		return fraction<T>(frac_adder_eq1._up-frac_adder._up,frac_adder._down,true,true);
	}
	//operator *
	fraction<T> operator * (T another_adder){
		T gcd_num;
		if((gcd_num=math::gcd(_down,another_adder))!=1)
			_down/=gcd_num,another_adder/=gcd_num;
		return fraction<T>(_up*another_adder,_down,false,false);
	}
	fraction<T> operator * (fraction<T> another_adder){
		if(multi_optimize){
			T gcd_num;
			if(math::gcd(_up,_down)!=1) reduction();
			if(math::gcd(another_adder._up,another_adder._down)!=1) another_adder.reduction();
			if((gcd_num=math::gcd(_up,another_adder._down))!=1) 
				_up/=gcd_num,another_adder._down/=gcd_num;
			if((gcd_num=math::gcd(_down,another_adder._up)!=1))
				_down/=gcd_num,another_adder._up/=gcd_num;
			return fraction<T>(_up*another_adder._up,_down*another_adder._down,false,false); 
		}
		else{
			return fraction<T>(_up*another_adder._up,_down*another_adder._down,true,true);
		}
	}
	friend fraction<T> operator * (T adder,fraction<T> frac_adder){
		T gcd_num;
		if((gcd_num=math::gcd(frac_adder._down,adder))!=1)
			frac_adder._down/=gcd_num,adder/=gcd_num;
		return fraction<T>(frac_adder._up*adder,frac_adder._down,false,false);
	}
	//operator /
	fraction<T> operator / (T divider){
		return operator * (fraction<T>(divider,1,multi_optimize));
	} 
	fraction<T> operator / (fraction<T> divider){
		return operator * (divider.reciprocal(!multi_optimize));
	}
	friend fraction<T> operator / (T dividend,fraction<T> divider){
		return operator * (dividend,divider.reciprocal(false));
	}
	// operator < , == , != , > , <= , >= 
	// operator <
	bool operator < (fraction<T> frac_arg)const{
		two_fracs<T> commoned=common_value(*this,frac_arg);
		return commoned.first._up<commoned.second._up;
	}
	bool operator < (T integer_arg)const{
		fraction<T> frac_arg_eqint(integer_arg*_down,_down,false,false);
		return _up<frac_arg_eqint._up;
	} 
	friend bool operator < (T integer_arg,fraction<T> frac_arg){
		fraction<T> frac_arg_eqint(integer_arg*frac_arg._down,frac_arg._down,false,false);
		return frac_arg._up<frac_arg_eqint._up;
	}
	// operator ==
	bool operator == (fraction<T> frac_arg)const{
		two_fracs<T> commoned=common_value(*this,frac_arg);
		return commoned.first._up==commoned.second._up;
	}
	bool operator == (T integer_arg)const{
		fraction<T> frac_arg_eqint(integer_arg*_down,_down,false,false);
		return _up==frac_arg_eqint._up;
	} 
	friend bool operator == (T integer_arg,fraction<T> frac_arg){
		fraction<T> frac_arg_eqint(integer_arg*frac_arg._down,frac_arg._down,false,false);
		return frac_arg._up==frac_arg_eqint._up;
	}
	// operator !=
	bool operator != (fraction<T> frac_arg)const{
		two_fracs<T> commoned=common_value(*this,frac_arg);
		return commoned.first._up!=commoned.second._up;
	}
	bool operator != (T integer_arg)const{
		fraction<T> frac_arg_eqint(integer_arg*_down,_down,false,false);
		return _up!=frac_arg_eqint._up;
	} 
	friend bool operator != (T integer_arg,fraction<T> frac_arg){
		fraction<T> frac_arg_eqint(integer_arg*frac_arg._down,frac_arg._down,false,false);
		return frac_arg._up!=frac_arg_eqint._up;
	}
	// operator >
	bool operator > (fraction<T> frac_arg)const{
		two_fracs<T> commoned=common_value(*this,frac_arg);
		return commoned.first._up>commoned.second._up;
	}
	bool operator > (T integer_arg)const{
		fraction<T> frac_arg_eqint(integer_arg*_down,_down,false,false);
		return _up>frac_arg_eqint._up;
	} 
	friend bool operator > (T integer_arg,fraction<T> frac_arg){
		fraction<T> frac_arg_eqint(integer_arg*frac_arg._down,frac_arg._down,false,false);
		return frac_arg._up>frac_arg_eqint._up;
	}
	// operator <=
	bool operator <= (fraction<T> frac_arg)const{
		two_fracs<T> commoned=common_value(*this,frac_arg);
		return commoned.first._up<=commoned.second._up;
	}
	bool operator <= (T integer_arg)const{
		fraction<T> frac_arg_eqint(integer_arg*_down,_down,false,false);
		return _up<=frac_arg_eqint._up;
	} 
	friend bool operator <= (T integer_arg,fraction<T> frac_arg){
		fraction<T> frac_arg_eqint(integer_arg*frac_arg._down,frac_arg._down,false,false);
		return frac_arg._up<=frac_arg_eqint._up;
	}
	// operator >=
	bool operator >= (fraction<T> frac_arg)const{
		two_fracs<T> commoned=common_value(*this,frac_arg);
		return commoned.first._up>=commoned.second._up;
	}
	bool operator >= (T integer_arg)const{
		fraction<T> frac_arg_eqint(integer_arg*_down,_down,false,false);
		return _up>=frac_arg_eqint._up;
	} 
	friend bool operator >= (T integer_arg,fraction<T> frac_arg){
		fraction<T> frac_arg_eqint(integer_arg*frac_arg._down,frac_arg._down,false,false);
		return frac_arg._up>=frac_arg_eqint._up;
	}
	// operator += , -= , *= , /=
	// operator +=
	fraction<T> operator += (fraction<T> add_num){
		return *this=*this+add_num;
	}
	fraction<T> operator += (T add_num){
		return *this=*this+add_num;
	}
	friend fraction<T> operator += (T add_num,fraction<T> add_frac){
		return add_frac=add_frac+add_num;
	}
	// operator -=
	fraction<T> operator -= (fraction<T> add_num){
		return *this=*this-add_num;
	}
	fraction<T> operator -= (T add_num){
		return *this=*this-add_num;
	}
	friend fraction<T> operator -= (T add_num,fraction<T> add_frac){
		return add_frac=add_frac-add_num;
	}
	// operator *=
	fraction<T> operator *= (fraction<T> add_num){
		return *this=*this*add_num;
	}
	fraction<T> operator *= (T add_num){
		return *this=*this*add_num;
	}
	friend fraction<T> operator *= (T add_num,fraction<T> add_frac){
		return add_frac=add_frac*add_num;
	}
	// operator /=
	fraction<T> operator /= (fraction<T> add_num){
		return *this=*this/add_num;
	}
	fraction<T> operator /= (T add_num){
		return *this=*this/add_num;
	}
	friend fraction<T> operator /= (T add_num,fraction<T> add_frac){
		return add_frac=add_frac/add_num;
	}
	private:
	template<typename T1,typename T2=T1>
	struct two_fracs{
		fraction<T1> first;
		fraction<T2> second;
		two_fracs(){}
		two_fracs(fraction<T1> new_1,fraction<T2> new_2){
			first=new_1,second=new_2;
		}
	};
	template<typename T1,typename T2=T1>
	static two_fracs<T1,T2> common_value(fraction<T1> frac_x,fraction<T2> frac_y){
		T1 gcd_num=math::gcd(frac_x._down,frac_y._down);
		T1 x_multi_num=frac_y._down/gcd_num,y_multi_num=frac_x._down/gcd_num;
		frac_x._down*=x_multi_num,frac_x._up*=x_multi_num;
		frac_y._down*=y_multi_num,frac_y._up*=y_multi_num;
		return two_fracs<T1,T2>(frac_x,frac_y);
	}
};

namespace math{
	template<typename T>
	fraction<T> reduction(fraction<T> the_frac){
		return the_frac.reduction();
	}
}
#endif

注意：分数与浮点数之间的运算要用这样的形式：

fraction<int> frac(1,2);
double doub=0.3;
cout<<frac.value()+doub; // 或 cout<<double(frac)+doub;

欢迎转载，但请在文章中附加上本文链接： https://blog.csdn.net/weixin_41461277/article/details/84890580 。

_ZGq
关注
专栏目录
c++ 实现分数类
liqiangzju的博客
01-21 1万+
/* * fraction.h * 此分数类在输入分数后符号将只储存在分子位上，分母为正数。在进行加减乘除运算后会自动进行约分，也可自己执行约分操作。 * Created on: 2016年11月18日 * */ #ifndef FRACTION_H_ #define FRACTION_H_ class fraction{ private: int numerator;
基于C++实现分数类
m0_58335239的博客
07-24 2205
该代码为基于c++实现分数类，是我大学oop课程的一个小作业，目前我并不很熟练编程，想通过分享的方式来让大佬们对这个代码提出一些修改建议。 该分数类的将分子和分母设置为int类型，将正负号设置为char类型，然后在共有部分为该类提供了取负运算、倒数运算、约分、小数转分数、字符串转分数，加减乘除，关系判断运算，输出等功能。 #include "iostream" #include "math.h" using namespace std; class fraction {...
C++ 分数类
weixin_34397291的博客
03-13 362
class fraction{private:int above; //分子int below; //分母void reduction(); //约分fraction makeCommond(fraction); //通分public:fraction(int a=0,int b=1){ //构造函数 above=a;below...
狐猬编程C++2级 第11课 简单的下标计数 开会时间
2401_85014072的博客
08-21 670
一年一度的信息学奥林匹克总结大会准备召开了，但大会负责人Mr.Huang却遇到了麻烦，参加会议的各中小学信息学教练都非常非常忙，因为他们不但要担任竞赛的辅导工作，而且还有常规的教学工作，有的还担任学校的行政职务，因此要召集他们都来开会是一件非常困难的事，为了让更多的人来参加会议，时间的选择非常关键。自然是能来的人越多越好，在这个前提下，请你确定某一天开会，如何能来的人数相同的话，会越早开越好，当然如何与会人数小于组委会设定的最少人数，会议将被取消。接下来有N行，第i行表示第i个教练有空的时间。
用C++语言描述分数类，并进行各种运算
05-25
用C++进行描述分数，使其能进行分数的各种运算
C++分数类
[PE]经典八炮的博客
04-17 1652
1.简介 我用C++做了一个分数类，实现了加减乘除、比较大小、约分、通分等功能。下面与大家分享一下代码（VS2019编译通过）。 2.代码 代码不难理解，用到的都是一些数学原理。 //CFraction.h #pragma once #include<stdexcept> class CFraction { private: typedef long long type; type numerator;//分子 type denominator;//分母 static type GCD(
分数类（C++）
weixin_56105279的博客
09-30 725
//自己添加一下c++的头文件 #include using namespace std; class Fraction{ private: int denominator; int numerator; int calDivisor(int n1,int n2){ while(n2!= 0){ int r = n1 % n2; n1 = n2; n2 = r; } return n1; } public: Fraction(){ } Fraction(int n1,int n2){ denominator
C++实践分数类中运算符重载的方法参考
01-21
（1）实现分数类中的运算符重载，在分数类中可以完成分数的加减乘除（运算后再化简）、比较（6种关系）的运算。 class CFraction { private: int nume; // 分子 int deno; // 分母 public: //构造函数及运算符...
c++实现分数计算器.zip
11-15
代码共计600行，实现了分数加减、分数排序、分数自加减、分数转小数功能，优化了界面设置和代码规范性，主体程序含有注释，实现了基础的应用程序框架（菜单跳转、返回、功能实现），同时，我考虑到了各种输入不标准...
分数类 c++
lixuefeng2305的博客
03-13 319
#include <iostream> #include <cmath> using namespace std; class Fraction { public: Fraction(); Fraction(int numer, int deno); Fraction(int numer); int get_numerator(const Fraction& fraction) { return fraction.numerator_var; .
用c++实现分数（fraction）类
最新发布
2201_75683257的博客
09-23 514
这是一个用c++实现的分数类，功能还算完善
c++分数类，完美实现了分数的四则运算
05-13
完美的c++分数类，实现了分数的四则运算
c++写的分数类，可进行运算操作和比较操作及和浮点数据的转换操作
03-18
c++写的分数类，可进行运算操作和比较操作及和浮点数据的转换操作，可供面向对象学习参考使用
C++课程设计（分数类）
12-08
设计一个分数类，分子分母都是整数，该分数类可以进行两个分数的加、减、乘、除、比较大小。并对可以对结果化简，也可以对输入的单个分数取倒数，化简，最终结果能以分式形式输出，也能以小数形式输出。
C++第5周项目2 - 分数类
迂者-贺利坚的专栏
03-29 4756
课程首页地址：http://blog.csdn.net/sxhelijian/article/details/7910565，本周题目链接：http://blog.csdn.net/sxhelijian/article/details/8723847【项目2】C++中提供了多种基本的数据类型。实际上，这些远不能满足我们的需求，如复数（第10章的例子大多是处理虚数的），再如分数。本任务将设计一个简单
C++分数类（大整数类版）
[PE]经典八炮的博客
05-21 827
1.简介 该博文是C++分数类的姊妹篇。那篇博文中type对应的类型是long long，虽然范围很大，但还是可能溢出。我最近做了一个大整数类，理论上可以保存无限大的整数，于是，我把这两个类结合了起来，并添加了一些新功能，就成了这个版本的分数类。 2.代码 改进后的分数类代码如下：（测试代码见第一篇博客） //CFraction.h #pragma once #include<stdexcept> #include"CBigInt.h" class CFraction { private: t
c++分数类
(ง •̀_•́)ง
11-12 9626
以下这个代码是将头文件、对应的实现文件和main.cpp放在一起的，只要稍微改一下预处理指令就能拆成三部分。 　　#include #include class fraction{ private: int numerator;//分子 int denominator;//分母 int gcd(int x,int y)const;//最大公约数 int lcm(int x,int
[SHOI2002]百事世界杯之旅
weixin_30445169的博客
09-13 258
题目：“……在2002年6月之前购买的百事任何饮料的瓶盖上都会有一个百事球星的名字。只要凑齐所有百事球星的名字，就可参加百事世界杯之旅的抽奖活动，获得球星背包，随声听，更克赴日韩观看世界杯。还不赶快行动！” 你关上电视，心想：假设有n个不同的球星名字，每个名字出现的概率相同，平均需要买几瓶饮料才能凑齐所有的名字呢？ 输入\(n(2\le n\le33)\)，以带分数or整数的形式输出购买的期望数。...
[C++]分数类的定义（成员函数、运算符重载）
cumtLeibnizDavid的博客
07-21 2622
C++分数类的实现
c++实现分数类fraction
05-14
下面是一个简单的 C++ 分数类 `fraction` 的实现，它包含了分数的四则运算和比较运算。 ```cpp #include <iostream> using namespace std; class fraction { private: int num; // 分子 int den; // 分母 public: fraction(int n = 0, int d = 1) { if (d == 0) { cout << "分母不能为0！" << endl; exit(1); } if (d < 0) { n = -n; d = -d; } num = n; den = d; reduce(); } int getNum() const { return num; } int getDen() const { return den; } fraction operator-() const { return fraction(-num, den); } friend fraction operator+(const fraction& f1, const fraction& f2); friend fraction operator-(const fraction& f1, const fraction& f2); friend fraction operator*(const fraction& f1, const fraction& f2); friend fraction operator/(const fraction& f1, const fraction& f2); friend bool operator==(const fraction& f1, const fraction& f2); friend bool operator!=(const fraction& f1, const fraction& f2); friend bool operator<(const fraction& f1, const fraction& f2); friend bool operator>(const fraction& f1, const fraction& f2); friend bool operator<=(const fraction& f1, const fraction& f2); friend bool operator>=(const fraction& f1, const fraction& f2); friend istream& operator>>(istream& in, fraction& f); friend ostream& operator<<(ostream& out, const fraction& f); private: void reduce() { int gcd = getGCD(num, den); num /= gcd; den /= gcd; } int getGCD(int a, int b) { if (b == 0) return a; return getGCD(b, a % b); } }; fraction operator+(const fraction& f1, const fraction& f2) { return fraction(f1.getNum() * f2.getDen() + f2.getNum() * f1.getDen(), f1.getDen() * f2.getDen()); } fraction operator-(const fraction& f1, const fraction& f2) { return f1 + (-f2); } fraction operator*(const fraction& f1, const fraction& f2) { return fraction(f1.getNum() * f2.getNum(), f1.getDen() * f2.getDen()); } fraction operator/(const fraction& f1, const fraction& f2) { return fraction(f1.getNum() * f2.getDen(), f1.getDen() * f2.getNum()); } bool operator==(const fraction& f1, const fraction& f2) { return f1.getNum() == f2.getNum() && f1.getDen() == f2.getDen(); } bool operator!=(const fraction& f1, const fraction& f2) { return !(f1 == f2); } bool operator<(const fraction& f1, const fraction& f2) { return f1.getNum() * f2.getDen() < f2.getNum() * f1.getDen(); } bool operator>(const fraction& f1, const fraction& f2) { return f2 < f1; } bool operator<=(const fraction& f1, const fraction& f2) { return !(f2 < f1); } bool operator>=(const fraction& f1, const fraction& f2) { return !(f1 < f2); } istream& operator>>(istream& in, fraction& f) { char slash; in >> f.num >> slash >> f.den; f.reduce(); return in; } ostream& operator<<(ostream& out, const fraction& f) { out << f.getNum() << '/' << f.getDen(); return out; } int main() { fraction f1(1, 2), f2(3, 4), f3; cout << "f1 = " << f1 << endl; cout << "f2 = " << f2 << endl; cout << "f3 = " << f3 << endl; cout << "请输入一个分数："; cin >> f3; cout << "f3 = " << f3 << endl; cout << "f1 + f2 = " << f1 + f2 << endl; cout << "f1 - f2 = " << f1 - f2 << endl; cout << "f1 * f2 = " << f1 * f2 << endl; cout << "f1 / f2 = " << f1 / f2 << endl; cout << "f1 == f2 ? " << (f1 == f2) << endl; cout << "f1 != f2 ? " << (f1 != f2) << endl; cout << "f1 < f2 ? " << (f1 < f2) << endl; cout << "f1 > f2 ? " << (f1 > f2) << endl; cout << "f1 <= f2 ? " << (f1 <= f2) << endl; cout << "f1 >= f2 ? " << (f1 >= f2) << endl; return 0; } ``` 上述实现中，分数类 `fraction` 的成员变量包括分子 `num` 和分母 `den`，它们在构造函数中被初始化。构造函数中还进行了分母为零的判断和分数的约分处理。`fraction` 类重载了一些运算符，包括一元负号运算符、二元加减乘除运算符和比较运算符。此外，还重载了输入输出流运算符，方便用户输入和输出分数。在主函数中，演示了如何使用这些运算符进行分数的运算和比较。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值