一个简单的分数类

于 2020-08-06 11:39:14 发布
阅读量381 收藏 2
点赞数
文章标签： c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/freshman_T_T/article/details/107821236
版权 
                            C++的一个简单的分数类

最近老师布置了一个分数类的作业，完成之后决定写出来和大家分享一下，本人是一个小白，程序中难免会有许多不完善的地方，希望大家能多多谅解。
本文主要使用了几个自己编写的头文件（函数）和一个类定义来实现程序

目录

程序使用形式

分数的加减乘除和比较通分
（+ - * / < > <= >= == !=）
如：
输入 1/2 + 1/3 输出 5/6
输入 1/2 < 1/3 输出 FLASE

几个重要的头文件

1.最大公因数和最小公倍数

#ifndef __FACTOR_H__
#define __FACTOR_H__    //定义文件名（factor.h）
// 最大公因数
int factor(int a, int b)
{H
	a = (a%b == 0 ? b : factor(b, a%b));  //使用了函数的递归
	return a;
}
#endif

#ifndef __MULTIPLE_H_
#define __MULTIPLE_H_  // 定义文件名（multiple.h）
#include"factor.h"    //使用上面定义的公因数函数
//公倍数
int multiple(int a, int b)
{
	int k;
	k = (a%b == 0 ? b : factor(b, a%b));
	k = (a / k)*(b / k)*k;
	return k;
}
#endif

2.将输入的字符串转化为数字，并求出分子分母

比如我们输入 1/8 ，这个函数可以帮我们将1， 8 分离出来
分子分母思路一样，返回值不同，下面只展示返回分子的头文件

#ifndef __NUMERATOR_T__
#define __NUMERATOR_T__ //定义文件名（numerator.h）
#include<math.h>
//求分子
int numerator(char a[20])  //返回分子值，形参是一段字符，且假设长度小于20
{
	char x[20] = { "0" }; char y[20] = { "0" }; // x用于分子，y用于分母
	int k = 0;   int fenzi; int fenmu;
	for (int n = 0; n <= 19; n++)   //20-1
	{
		if (a[n] != '/')    //当遇到“/”时停下
		{
			x[n] = a[n];
		}
		else { k = n; break; }

	}
	fenzi = k; //分子位数
	for (int n = 0; k <= 18; k++, n++)    //20-2
	{
		if (a[k + 1] != '\0')
		{
			y[n] = a[k + 1];
		}
		else { fenmu = n; break; } // 分母位数

	}                               
     // cout<<x<<y 即可检验是否出错
	 //下面将字符如“123”转换为int 123
	int zi = 0; int mu = 0;
	int wei = 0;
	for (int n = fenzi - 1; n >= 0; n--) //从分子个位开始
	{
		int shu;
		if (n > 0 || a[n] != '-')
		{
			shu = int(a[n]) - 48;
			zi = zi + pow(10, wei)*shu; wei++;
		}
		else { zi = -zi; break; }    //分子为负数的情况下
	}
	wei = 0;
	for (int n = fenmu + fenzi; n > fenzi; n--)
	{
		int shu;
		shu = int(a[n]) - 48;
		mu = mu + pow(10, wei)*shu; wei++;
	}

	return zi; //返回int型 分子值

};
#endif //

3.判断进行何种运算
这个函数先涉及了类定义，有疑问的兄弟可以先跳过

#ifndef __DOUBLE_H__
#define __DOUBLE_H__   //定义文件名（double.h）
#include <iostream>
using namespace std;
#include <math.h>
#include"numerator.h"         //numerator 取分子
#include"denominator.h"        //denominator  取分母
#include"factor.h"       //Common factor 公因数
#include"multiple.h"       //Common multiple 公倍数
#include"fraction.h "             //fraction 分数类的定义
#include"positive.h"       //Positive number 取正数 很简单的函数略过
void doubles(char o,char *A,char *B)//三个形参，A，B代表两个分数
{ 
	// 字符 o 利用字母（ABCD……）代表+ - / * > < >= <= == !=
	switch (o)
	{
	case 'A':                                            
	{
		fraction fra1; fraction fra2(A); fraction fra3(B);
		fra1 = fra2 + fra3; //类的自定义加法，在类定义中重载
		fra1.showout1();   //类的输出函数
	}
		break;
	case 'B':
	{
		fraction fra1; fraction fra2(A); fraction fra3(B);
		fra1 = fra2 - fra3;
		fra1.showout1();
	}
       
	break;
	case 'C':
	{
		fraction fra1; fraction fra2(A); fraction fra3(B);
		fra1 = fra2 * fra3;
		fra1.showout1();
	}

	break;
	case 'D':
	{
		fraction fra1; fraction fra2(A); fraction fra3(B);
		fra1 = fra2 / fra3;
		fra1.showout1();
	}

	break;
	case 'E':
	{
		fraction fra1; fraction fra2(A); fraction fra3(B);
		fra1 = fra2 || fra3;  // 两个分数通分
	}

	break;
	case 'F':
	{
		fraction fra1; fraction fra2(A); fraction fra3(B);
		fra1 = fra2 > fra3;
		fra1.showout2(); //类的另一种输出函数
	}
	break;
	case'G':
	{
		fraction fra1; fraction fra2(A); fraction fra3(B);
		fra1 = fra2 < fra3;
		fra1.showout2();
	}

	break;
	case'H':
	{
		fraction fra1; fraction fra2(A); fraction fra3(B);
		fra1 = fra2 >= fra3;
		fra1.showout2();
	}

	break;
	case'I':
	{
		fraction fra1; fraction fra2(A); fraction fra3(B);
		fra1 = fra2 <= fra3;
		fra1.showout2();
	}

	break;
	case'J':
	{
		fraction fra1; fraction fra2(A); fraction fra3(B);
		fra1 = fra2 == fra3;
		fra1.showout2();
	}

	break;
	case'K':
	{
		fraction fra1; fraction fra2(A); fraction fra3(B);
		fra1 = fra2 != fra3;
		fra1.showout2();
	}

	break;
	default:cout << "错误的输入" << endl;
	}

};

#endif // !1

类定义

定义类 fraction

#ifndef __FRACTION_H__
#define __FRACTION_H__
#include <math.h>
#include"numerator.h"         //numerator 取分子
#include"denominator.h"        //denominator  取分母
#include"factor.h"       //Common factor 公因数
#include"multiple.h"       //Common multiple 公倍数
#include"positive.h"       //Positive number 取正数
using namespace std;
//定义一个类的运算，通过运算符的重载来实现双目运算符的实现
class
	fraction
{

public:
	fraction(const char*str) //构造函数实现初始化
	{
		a = new char[20];
		strcpy(a, str);
	}
	fraction() {};
	//下面都是重载运算符，以友元函数形式出现
	friend fraction operator + (const fraction &b1, const fraction &b2);
	friend fraction operator - (const fraction &b1, const fraction &b2);
	friend fraction operator * (const fraction &b1, const fraction &b2);
	friend fraction operator / (const fraction &b1, const fraction &b2);
	friend fraction operator > (const fraction &b1, const fraction &b2);
	friend fraction operator < (const fraction &b1, const fraction &b2);
	friend fraction operator >= (const fraction &b1, const fraction &b2);
	friend fraction operator <= (const fraction &b1, const fraction &b2);
	friend fraction operator != (const fraction &b1, const fraction &b2);
	friend fraction operator == (const fraction &b1, const fraction &b2);
	friend fraction operator || (const fraction &b1, const fraction &b2); //通分运算符
	void showout1()
	{    // 避免输出1/-2 的情况
		 if (mu < 0 && zi>0)
		 {
			 cout << -zi << "/" << -mu<<endl;
		 }
		 if (mu < 0 && zi <= 0)
		 {
			cout << -zi << "/" << -mu<<endl;
		 }
		 if (mu > 0 && zi > 0)
		 {
			cout << zi << "/" << mu<<endl ;
		 }
		 if (mu > 0 && zi <= 0)
		 {
			 cout<< zi << "/" << mu<<endl;
		 }
		 if (mu == 0)
		 {
			 cout << " 分母为0，错误！"<<endl;
		 }
	};
	void showout2()
	{
		if (boo1 == 1) { cout << "TURE"<<endl; }
		if (boo1 == 0) { cout<< "FLASE"<<endl; }
	}
	int x, y;
private:
	char *a;
	int zi, mu;  //分子，分母
	int boo1;    //对错
};
fraction operator + (const fraction &b1, const fraction &b2)
{   
	fraction fra; // 返回一个fraction 类
	int x1, x2, y1, y2;
	x1 = numerator(b1.a); x2 = numerator(b2.a);  //取分子
	y1 = denominator(b1.a); y2 = denominator(b2.a);  //取分母
	int z1; z1 = factor(y1, y2); //公因数
	int z2; z2 = multiple(y1, y2); //公倍数
	fra.zi = x1 * (z2 / y1) + x2 * (z2 / y2);
	fra.mu = z2;
	//上下约分
	fra.x = positive(fra.zi); //取正数
	fra.y = positive(fra.mu);
	fra.x = factor(fra.x, fra.y); 
	fra.zi = fra.zi / fra.x;
	fra.mu = fra.mu / fra.x;
	return fra;
}
//同加法
fraction operator - (const fraction &b1, const fraction &b2)
{
	fraction fra;
	int x1, x2, y1, y2;
	x1 = numerator(b1.a); x2 = numerator(b2.a);
	y1 = denominator(b1.a); y2 = denominator(b2.a);
	int z1; z1 = factor(y1, y2);
	int z2; z2 = multiple(y1, y2);
	fra.zi = x1 * (z2 / y1) - x2 * (z2 / y2);
	fra.mu = z2;
	fra.x = positive(fra.zi);
	fra.y = positive(fra.mu);
	fra.x = factor(fra.x, fra.y);
	fra.zi = fra.zi / fra.x;
	fra.mu = fra.mu / fra.x;
	return fra;
}
fraction operator * (const fraction &b1, const fraction &b2)
{
	fraction fra;
	int x1, x2, y1, y2;
	x1 = numerator(b1.a); x2 = numerator(b2.a);
	y1 = denominator(b1.a); y2 = denominator(b2.a);
	int z1; z1 = factor(y1, y2);
	int z2; z2 = multiple(y1, y2);
	fra.zi = x1 * x2;
	fra.mu = y1 * y2;
	fra.x = positive(fra.zi);
	fra.y = positive(fra.mu);
	fra.x = factor(fra.x, fra.y);
	fra.zi = fra.zi / fra.x;
	fra.mu = fra.mu / fra.x;
	return fra;
}

fraction operator / (const fraction &b1, const fraction &b2)
{
	fraction fra;
	int x1, x2, y1, y2;
	x1 = numerator(b1.a); x2 = numerator(b2.a);
	y1 = denominator(b1.a); y2 = denominator(b2.a);
	int z1; z1 = factor(y1, y2);
	int z2; z2 = multiple(y1, y2);
	fra.zi = x1 * y2;
	fra.mu = y1 * x2;
	fra.x = positive(fra.zi);
	fra.y = positive(fra.mu);
	fra.x = factor(fra.x, fra.y);
	fra.zi = fra.zi / fra.x;
	fra.mu = fra.mu / fra.x;
	return fra;
}
fraction operator > (const fraction &b1, const fraction &b2)
{
	fraction fra;
	int x1, x2, y1, y2;
	x1 = numerator(b1.a); x2 = numerator(b2.a);
	y1 = denominator(b1.a); y2 = denominator(b2.a);
	int z1; z1 = factor(y1, y2);
	int z2; z2 = multiple(y1, y2);
	if ((x1 * (z2 / y1)) > (x2 * (z2 / y2)))
	{
		fra.boo1 = 1;
	}
	else { fra.boo1 = 0; }
	return fra;
}
fraction operator < (const fraction &b1, const fraction &b2)
{
	fraction fra;
	int x1, x2, y1, y2;
	x1 = numerator(b1.a); x2 = numerator(b2.a);
	y1 = denominator(b1.a); y2 = denominator(b2.a);
	int z1; z1 = factor(y1, y2);
	int z2; z2 = multiple(y1, y2);
	if ((x1 * (z2 / y1)) < (x2 * (z2 / y2)))
	{
		fra.boo1 = 1;
	}
	else { fra.boo1 = 0; }
	return fra;
}

fraction operator >= (const fraction &b1, const fraction &b2)
{
	fraction fra;
	int x1, x2, y1, y2;
	x1 = numerator(b1.a); x2 = numerator(b2.a);
	y1 = denominator(b1.a); y2 = denominator(b2.a);
	int z1; z1 = factor(y1, y2);
	int z2; z2 = multiple(y1, y2);
	if ((x1 * (z2 / y1)) >= (x2 * (z2 / y2)))
	{
		fra.boo1 = 1;
	}
	else { fra.boo1 = 0; }
	return fra;
}
fraction operator <= (const fraction &b1, const fraction &b2)
{
	fraction fra;
	int x1, x2, y1, y2;
	x1 = numerator(b1.a); x2 = numerator(b2.a);
	y1 = denominator(b1.a); y2 = denominator(b2.a);
	int z1; z1 = factor(y1, y2);
	int z2; z2 = multiple(y1, y2);
	if ((x1 * (z2 / y1)) <= (x2 * (z2 / y2)))
	{
		fra.boo1 = 1;
	}
	else { fra.boo1 = 0; }
	return fra;
}
fraction operator == (const fraction &b1, const fraction &b2)
{
	fraction fra;
	int x1, x2, y1, y2;
	x1 = numerator(b1.a); x2 = numerator(b2.a);
	y1 = denominator(b1.a); y2 = denominator(b2.a);
	int z1; z1 = factor(y1, y2);
	int z2; z2 = multiple(y1, y2);
	if ((x1 * (z2 / y1)) == (x2 * (z2 / y2)))
	{
		fra.boo1 = 1;
	}
	else { fra.boo1 = 0; }
	return fra;
}
fraction operator != (const fraction &b1, const fraction &b2)
{
	fraction fra;
	int x1, x2, y1, y2;
	x1 = numerator(b1.a); x2 = numerator(b2.a);
	y1 = denominator(b1.a); y2 = denominator(b2.a);
	int z1; z1 = factor(y1, y2);
	int z2; z2 = multiple(y1, y2);
	if ((x1 * (z2 / y1)) != (x2 * (z2 / y2)))
	{
		fra.boo1 = 1;
	}
	else { fra.boo1 = 0; }
	return fra;
}
//通分直接输出
fraction operator || (const fraction &b1, const fraction &b2)
{
	fraction fra;
	int x1, x2, y1, y2;
	x1 = numerator(b1.a); x2 = numerator(b2.a);
	y1 = denominator(b1.a); y2 = denominator(b2.a);
	int z1; z1 = factor(y1, y2);
	int z2; z2 = multiple(y1, y2);
	fra.zi = x1 * (z2 / y1) + x2 * (z2 / y2);
	fra.mu = z2;
	cout << x1 * (z2 / y1) << "/" << z2 << " " << x2 * (z2 / y2) << "/" << z2 << endl;
	return fra;
};
#endif // !__FRACTION_H__
主程序

由于我们将重要的程序都分块放到了头文件中，主程序只需要判断执行什么双目运算

#include <iostream>
#include <math.h>
#include"numerator.h"         //numerator 取分子
#include"denominator.h"        //denominator  取分母
#include"factor.h"       //Common factor 公因数
#include"multiple.h"       //Common multiple 公倍数
#include"fraction.h"          //fraction 分数类的定义
#include"positive.h"       //Positive number 取正数
#include"double.h"      //双目运算符的选择
using namespace std;
int main()                                                   
{
	char a[20], b[20], c[20];
        cin>>a,cin>>b;cin>> c;
        char B= '0'
		{
			//判断是什么双目运算符
			if (strcmp(b, "+") == 0) //字符比较函数在标准库中
				B = 'A';
			else if (strcmp(b, "-") == 0)
				B = 'B';
			else if (strcmp(b, "*") == 0)
				B = 'C';
			else if (strcmp(b, "/") == 0)
				B = 'D';
			else if (strcmp(b, "tongfen") == 0)                   //通分
				B = 'E';
			else if (strcmp(b, ">") == 0)
				B = 'F';
			else if (strcmp(b, "<") == 0)
				B = 'G';
			else if (strcmp(b, ">=") == 0)
				B = 'H';
			else if (strcmp(b, "<=") == 0)
				B = 'I';
			else if (strcmp(b, "==") == 0)
				B = 'J';
			else if (strcmp(b, "!=") == 0)
				B = 'K';

			doubles(B, a, c); //执行双目运算
		}
	}
                                                                                                       
	return 0;

}
写在最后

本次的分数类是较为简单的，虽然看上去又臭又长，但只要写了一会就发现
大部分的工作都是相似的。作为小白，有些低级的错误让大家见笑了

下面放出我们的作业，多了单目的运算
在这里插入图片描述

freshman_T_T
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
定义和使用分数类fraction
01-06
1.自定义分数类fraction，使用该类可以完成分数的输入、分数的加、减、乘、除二目运算和一目减运算、分数的约分操作、分数的倒数运算、对两个分数进行六种比较运算、以及对分数的输出等操作。 2.将其中使用的普通函数尽量改写成运算符重载函数。如，可重载+、-、*、/、>、>=、<、<=、==、!=，以实现分数的各种运算。并且实现分数与整数的混合运算。 3.尽可能考虑程序的性能。 评分标准 1. 对两个类的成员合理地使用访问权限：1分 2. 实现分数与整数的混合运算：1分 3. 程序结构合理，布局清晰，正确地安排.h和.cpp：2分 4. 考虑程序的性能：1分 这个作业可以用到以下C++知识： 定义类，运算符重载、类型转换。
创建一个Computer类
07-23
准备工作：创建一个Computer类 要求成员变量包括如下： (1)编号（即计算机的唯一标识） (2)CPU型号， (3)主板型号， (4)硬盘大小， (5)内存大小， (6)显卡型号， (7)价格， 题目： （1）要求使用ArrayList存储...
实现一个分数类，包括加减乘除比大小等操作
哪惧明天，风高路斜
06-10 964
def gcd(m, n): while m % n != 0: oldm = m oldn = n m = oldn n = oldm % oldn return n class Fraction: def __init__(self, top, bottom): self.num = t...
分数类的构造
浮云渐渐
09-14 1093
#include //using namespace std; class CFraction { private: int nume; // 分子 int deno; // 分母 public: CFraction(int n=0,int d=0); CFraction operator +(CFraction &c); CFraction operator -(CFractio
分数类的实现
ThistleZhang
06-08 1228
实现一个分数类，并重载其加减运算 #include #include using namespace std; class Fraction{ private: int a; //分子 int b; //分母 int divisor(int p, int q); //求最大公约数 public: Fraction(){a=0;b=1;} //无参构造函
设计并实现一个分数类Fraction
_C9的博客
04-23 3619
描述 一个分数有两部分组成——分子和分母，如5/6 为Fraction类定义实现赋值、加、减、乘、除以及相等判定的运算符， 并定义转换至double型值的函数(保留小数点后六位) 输入 输入一个分数计算表达式，分数用a/b表示，计算符只有+,-,*,/ 表达式比较简单，只有 A operator B，其中A和B是分数，operator是计算符 输出 输出计算结果，分别用分数和小数的形...
C++实践分数类中运算符重载的方法参考
01-21
【项目-分数类中的运算符重载】 （1）实现分数类中的运算符重载，在分数类中可以完成分数的加减乘除（运算后再化简）、比较（6种关系）的运算。 class CFraction { private: int nume; // 分子 int deno; // ...
一个简单的学生课程系统
06-07
题目描述：一个简单的学生课程系统，可以创建学生，课程，成绩，以及计算最高对分。 功能要求： (1) 创建一个学生类，包含学号，姓名，性别。 (2) 创建一个课程成绩类，包含课程名称和成绩。 (3) 创建一个学生课程...
ccleader:一个简单的排行榜
06-13
一个简单的排行榜这个有点简单的排行榜旨在展示一些在创建 Rails 应用程序时对我很重要的方法和设计决策。技术决策对于排行榜，持久性存储是一个非常简单的调用。 Redis 就是为这种数据而构建的，这使得 ZADD 和 ...
Python中分数的相关使用教程
09-22
主要介绍了Python中分数的相关使用教程,主要涉及分数的计算、约分等简单操作，是Python学习过程当中的基础，需要的朋友可以参考下
C++课程设计（分数类）
12-08
设计一个分数类，分子分母都是整数，该分数类可以进行两个分数的加、减、乘、除、比较大小。并对可以对结果化简，也可以对输入的单个分数取倒数，化简，最终结果能以分式形式输出，也能以小数形式输出。
分数——mooc《面向对象程序设计——Java语言》-(浙大翁凯）第一周编程题
dieshi8689的博客
06-12 751
题目内容： 设计一个表示分数的类Fraction。这个类用两个int类型的变量分别表示分子和分母。 这个类的构造函数是： Fraction(int a, int b) 构造一个a/b的分数。 这个类要提供以下的功能： double toDouble(); 将分数转换为double Fraction plus(Fraction r); ...
c#试验报告 构造分数类
易水寒(C/C++)
10-25 972
using System; using System.Collections.Generic; using System.Text; namespace 分数类 { class Fraction { private int numerator;//分子 public int Numerator { get {
（40.1）典型的运算符重载之构造分数类和典型运算符重载
喜欢打篮球的普通人
02-08 267
文章目录1.构造分数类 1.构造分数类 eg：构建一个“分数”类Fraction。 #include <iostream> #include <stdlib.h> using namespace std; class Fraction { //Fraction类表示分数 public: Fraction(int n=0,int d=1) : nume(n),den...
//21、定义一个分数类使得分数对象可以整体输入输出；实现分数类中的运算符重载（分子和分母均为整型）
qq_46340608的博客
05-31 842
//21、定义一个分数类，并为其重载>>和<<运算符，使得分数对象可以整体输入输出；实现分数类中的运算符重载（分子和分母均为整型） //，即分数的加、减、乘、除的运算（运算后要求化简） #include"iostream" using namespace std; #include"math.h" class fen { private: int x,y; public: fen(int a=0,int b=0):x(a),y(b){} friend istr...
一个有趣的算法问题：如何定义一个分数类
weixin_34191845的博客
05-02 452
一个来自于C++程序设计的经典问题。如何定义一个分数类，实现分数的约分化简，分数之间的加法、减法、乘法、除法四则运算？ 1.初见 刚看到这道题的时候，第一感觉是挺简单的啊，就是基本的面向对象，定义对应的加减乘除类就可以了啊，然而到了实现的时候才发现许多问题是说起来容易做起来难，在实现的过程中，发现了许多的注意点，以及算法。 最终得出结论：...
分数类(重载了四则运算、比较运算、输出)
Meloor的博客
02-09 440
当前版本 重载了四则运算 兼容了与整数的四则运算 重载了比较运算符>,>=,<,<=,== 重载了输出运算符 /*********************************************************************/ class Rational{ public: Rational(ll num,ll denomi)...
分数类
Ansicht's Blog
03-16 1296
int gcd(int x,int y){ return (x%y==0?y:gcd(y,x%y)); } int lcm(int x,int y){ return x/gcd(x,y)*y; } struct Fen{ int a,b; //分子 分母 Fen(){ a=0;b=1; }...
生成一个分数类
最新发布
05-24
好的，以下是一个简单的分数类的示例代码： ```python class Fraction: def __init__(self, numerator, denominator): self.numerator = numerator self.denominator = denominator def __str__(self): ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值