【作品】超实用C++分数类

引言

我们说，编程语言的精髓在于封装，而面向对象语言完胜面向过程语言的原因就是具有更好的可封装性，而C++就是这样的一种多范型语言，常用而复杂的工作完全不必在每一份源文件中重敲，就好像我们不需要自己手写printf()和scanf()一样，自建一个属于自己的头文件，可以为编程提供很大的帮助，我今天就要推荐一下我自己原创的分数类（实际上C++STL库有分数类，只是性能很低，而且使用极其不方便，而我的这个分数类具有很多前者不具备的优点，而且颇具工程码风，易于理解与更新）。

注：此为原创文章，转载则务必说明原出处。

Code

将下面的代码存入一个名为fraction.h文件中，并在同目录下的源文件中加上：#include“fraction”即可使用该分数类（使用方法见后面）。

或是在IDE存放头文件的目录下添加一个名为fraction.h的文件，放入该代码并编译，然后便可在该电脑的任何地方创建.cpp文件，并用#include <fraction>包含该文件。

 //拱大垲原创
 //分数类实现~~~0.8.5
 //fraction:分数
 //numerator:分子
 //denominator:分母
 //输入分数时请以回车结尾
 //输入部分如含有空格，则空格后面的部分会被忽略
 //fraction可缩写为fac，计算机可以识别

 #include <iostream>
 #include <cmath>

 #ifndef __fraction_h_
 #define __fraction_h_

 using namespace std;

 namespace std
 { 

 //分数类
 class fraction
 {
 public:
     static long long MCF(long long a, long long b);

     friend ostream& operator<< (ostream& os,const fraction& the_fraction);
     friend istream& operator>> (istream& is,fraction& the_fraction);

     friend fraction operator+  (const fraction& the_fraction_a,const fraction& the_fraction_b);
     friend fraction operator-  (const fraction& the_fraction_a,const fraction& the_fraction_b);
     friend fraction operator*  (const fraction& the_fraction_a,const fraction& the_fraction_b);
     friend fraction operator/  (const fraction& the_fraction_a,const fraction& the_fraction_b);
     friend fraction operator+= (fraction& the_fraction_a,const fraction& the_fraction_b);
     friend fraction operator-= (fraction& the_fraction_a,const fraction& the_fraction_b);
     friend fraction operator*= (fraction& the_fraction_a,const fraction& the_fraction_b);
     friend fraction operator/= (fraction& the_fraction_a,const fraction& the_fraction_b);
     friend fraction operator-  (const fraction& the_fraction);
     friend fraction operator++ (fraction& the_fraction);
     friend fraction operator++ (fraction& the_fraction,int);
     friend fraction operator-- (fraction& the_fraction);
     friend fraction operator-- (fraction& the_fraction,int);

     friend bool operator>  (fraction& the_fraction_a,const fraction& the_fraction_b);
     friend bool operator<  (fraction& the_fraction_a,const fraction& the_fraction_b);
     friend bool operator>= (fraction& the_fraction_a,const fraction& the_fraction_b);
     friend bool operator<= (fraction& the_fraction_a,const fraction& the_fraction_b);
     friend bool operator== (fraction& the_fraction_a,const fraction& the_fraction_b);
     friend bool operator!= (fraction& the_fraction_a,const fraction& the_fraction_b);

     fraction();
     fraction(long long the_numerator);
     fraction(long long the_numerator,long long the_denominator);
     fraction(fraction the_fraction_a,fraction the_fraction_b);

     double decimal();
     long long getnum();
     long long getden();
     void setnum(long long num);
     void setden(long long den);

 private:
     long long numerator;
     long long denominator; 

 };

 long long fraction::MCF(long long a, long long b)
 {
     return a==? b:MCF(b%a,a);
 }

 ostream& operator<< (ostream& os,const fraction& the_fraction)
 {
     bool book=the_fraction.numerator>=&&the_fraction.denominator>=||the_fraction.numerator<&&the_fraction.denominator<;
     if(book==false)
         os<<"(-";
     if(the_fraction.denominator!=)
         os<<abs(the_fraction.numerator)<<"/"<<abs(the_fraction.denominator);
     else
         os<<abs(the_fraction.numerator);
     if(book==false)
         os<<")";
     return os;
 }

 istream& operator>> (istream& is,fraction& the_fraction)
 {
     char input[];
     char ch;
     bool mid=false;
     bool is_pt=true;
     the_fraction.numerator=the_fraction.denominator=;
     cin>>input;
     for(int i=;;i++)
     {
         ch=input[i];
         if(ch=='\0')
             break;
         if(ch=='-')
         {
             is_pt=!is_pt;
             continue;
         }
         if(ch=='/')
         {
             mid=true;
             continue;
         }
         if(mid==false)
             the_fraction.numerator=the_fraction.numerator*+(ch-'');
         else
             the_fraction.denominator=the_fraction.denominator*+(ch-'');
     }
     if(mid==false)
         the_fraction.denominator=;
     if(the_fraction.denominator==)
     {
         cout<<"False,the denominator == 0!!!";
         return is;
     }
     long long mcf=fraction::MCF(the_fraction.numerator,the_fraction.denominator);
     the_fraction.numerator/=mcf;
     the_fraction.denominator/=mcf;
     if(!is_pt)
         the_fraction.numerator=-the_fraction.numerator;
     return is;
 }

 fraction operator+ (const fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     long long the_numerator=the_fraction_a.numerator*the_fraction_b.denominator+the_fraction_b.numerator*the_fraction_a.denominator;
     long long the_denominator=the_fraction_a.denominator*the_fraction_b.denominator;
     return fraction(the_numerator,the_denominator);
 }

 fraction operator- (const fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     long long the_numerator=the_fraction_a.numerator*the_fraction_b.denominator-the_fraction_b.numerator*the_fraction_a.denominator;
     long long the_denominator=the_fraction_a.denominator*the_fraction_b.denominator;
     return fraction(the_numerator,the_denominator);
 }
 fraction operator* (const fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     long long the_numerator=the_fraction_a.numerator*the_fraction_b.numerator;
     long long the_denominator=the_fraction_a.denominator*the_fraction_b.denominator;
     long long mcf=fraction::MCF(the_numerator,the_denominator);
     the_numerator/=mcf;
     the_denominator/=mcf;
     fraction the_fraction(the_numerator,the_denominator);
     return the_fraction;
 }

 fraction operator/(const fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     return the_fraction_a*fraction(the_fraction_b.denominator,the_fraction_b.numerator);
 }

 fraction operator+= (fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     return the_fraction_a=the_fraction_a+the_fraction_b;
 }

 fraction operator-= (fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     return the_fraction_a=the_fraction_a-the_fraction_b;
 }

 fraction operator*= (fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     return the_fraction_a=the_fraction_a*the_fraction_b;
 }

 fraction operator/= (fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     return the_fraction_a=the_fraction_a/the_fraction_b;
 }

 fraction operator-  (const fraction& the_fraction)
 {
     return -the_fraction;
 }

 fraction operator++ (fraction& the_fraction)
 {
     the_fraction=the_fraction+;
     return the_fraction;
 }
 fraction operator++ (fraction& the_fraction,int)
 {
     the_fraction=the_fraction+;
     return the_fraction-;
 }
 fraction operator-- (fraction& the_fraction)
 {
     the_fraction=the_fraction-;
     return the_fraction;
 }
 fraction operator-- (fraction& the_fraction,int)
 {
     the_fraction=the_fraction-;
     return the_fraction+;
 }

 bool operator>  (fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     return the_fraction_a.numerator*the_fraction_b.denominator>the_fraction_b.numerator*the_fraction_a.denominator;
 }
 bool operator<  (fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     return the_fraction_a.numerator*the_fraction_b.denominator<the_fraction_b.numerator*the_fraction_a.denominator;
 }
 bool operator>= (fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     return the_fraction_a.numerator*the_fraction_b.denominator>=the_fraction_b.numerator*the_fraction_a.denominator;
 }
 bool operator<= (fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     return the_fraction_a.numerator*the_fraction_b.denominator<=the_fraction_b.numerator*the_fraction_a.denominator;
 }
 bool operator== (fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     return the_fraction_a.numerator*the_fraction_b.denominator==the_fraction_b.numerator*the_fraction_a.denominator;
 }
 bool operator!= (fraction& the_fraction_a,const fraction& the_fraction_b)
 {
     return the_fraction_a.numerator*the_fraction_b.denominator!=the_fraction_b.numerator*the_fraction_a.denominator;
 }

 fraction::fraction()
 {
     numerator=;
     denominator=;
 }

 fraction::fraction(long long the_numerator)
 {
     numerator=the_numerator;
     denominator=;
 }

 fraction::fraction(long long the_numerator,long long the_denominator)
 {
     long long mcf=fraction::MCF(the_numerator,the_denominator);
     numerator=the_numerator/mcf;
     denominator=the_denominator/mcf;
 }

 fraction::fraction(fraction the_fraction_a,fraction the_fraction_b)
 {
     long long the_numerator=the_fraction_a.numerator*the_fraction_b.denominator;
     long long the_denominator=the_fraction_a.denominator*the_fraction_b.numerator;
     long long mcf=fraction::MCF(the_numerator,the_denominator);
     numerator=the_numerator/mcf;
     denominator=the_denominator/mcf;
 }

 double fraction::decimal()
 {
     return 1.0*numerator/denominator;
 }

 long long fraction::getnum()
 {
     return numerator;
 }
 long long fraction::getden()
 {
     return denominator;
 }
 void fraction::setnum(long long num)
 {
     numerator=num;
     long long mcf=fraction::MCF(numerator,denominator);
     numerator/=mcf;
     denominator/=mcf;
 }
 void fraction::setden(long long den)
 {
     if(den!=)
     {
         denominator=den;
         long long mcf=fraction::MCF(numerator,denominator);
         numerator/=mcf;
         denominator/=mcf;
     }
     else
     {
         cout<<"False,the denominator == 0!!!";
     }
 }

 typedef fraction fac;

 }

 #endif

使用方法

目录

• 简介
• 一目运算符重载
• 二目运算符重载
• 构造函数
• 成员函数
• 数据成员
• 注意事项

简介

一个重载了几乎所有运算符的分数类。

一目运算符重载

friend fraction operator-  (const fraction& the_fraction);

friend fraction operator++ (fraction& the_fraction);

friend fraction operator++ (fraction& the_fraction,int);

friend fraction operator-- (fraction& the_fraction);

friend fraction operator-- (fraction& the_fraction,int);

这些友元函数重载了前置与后置的自增自减运算符，以及取负运算符，如a是一个分数，-a表示a的相反数，a++/a--表示后置递增/递减，++a/--a表示前置递增/递减。

二目运算符重载

friend ostream& operator<< (ostream& os,const fraction& the_fraction);

friend istream& operator>> (istream& is,fraction& the_fraction);

该函数重载了输入输出运算符，使之可以用于cin/cout对象，如a是分数类对象，其值等于-4/3，cout<<a，将在屏幕上显示（-4/3）,cin>>a将读取一个整数加一个分数线再加一个整数，如42/43，输入完毕后以回车结尾，不可以以空格结尾，可以任意一个整数前加负号已输入分数（若输入-4/-3，则系统会按整数存储，即4/3）。

friend fraction operator+  (const fraction& the_fraction_a,const fraction& the_fraction_b);

friend fraction operator-  (const fraction& the_fraction_a,const fraction& the_fraction_b);

friend fraction operator*  (const fraction& the_fraction_a,const fraction& the_fraction_b);

friend fraction operator/  (const fraction& the_fraction_a,const fraction& the_fraction_b);

这四个运算符重载了+-*/四则运算，使之可以用于分数（计算结果若非最简分数，系统会自动约分）。

friend fraction operator+= (fraction& the_fraction_a,const fraction& the_fraction_b);

friend fraction operator-= (fraction& the_fraction_a,const fraction& the_fraction_b);

friend fraction operator*= (fraction& the_fraction_a,const fraction& the_fraction_b);

friend fraction operator/= (fraction& the_fraction_a,const fraction& the_fraction_b);

这四个函数重载了+=，-=，*=，/=复合运算符，使之可以用于分数，将返回其右面的表达式的值。

friend bool operator>  (fraction& the_fraction_a,const fraction& the_fraction_b);

friend bool operator<  (fraction& the_fraction_a,const fraction& the_fraction_b);

friend bool operator>= (fraction& the_fraction_a,const fraction& the_fraction_b);

friend bool operator<= (fraction& the_fraction_a,const fraction& the_fraction_b);

friend bool operator== (fraction& the_fraction_a,const fraction& the_fraction_b);

friend bool operator!= (fraction& the_fraction_a,const fraction& the_fraction_b);

该6个函数重载了关系运算符，使之可以用于分数。

构造函数

fraction();

此为默认构造函数，将分数初始化为0/1。

fraction(long long the_numerator);

此为转换构造函数，可以将一个long long类型的数据转换为分数，同时也可以显示调用，如：fraction a（10）；将创建一个值为10/1的分数。

fraction(long long the_numerator,long long the_denominator);

fraction(fraction the_fraction_a,fraction the_fraction_b);

此为最主要的构造函数，将两个参数的商作为分数的值。

如：fraction a（150,100）将创建一个值为3/2的分数。

如：fraction a（fraction（2，3），fraction（3,2））将创建一个值为1/1的分数。

成员函数

double decimal();

返回分子除以分母的double型值。

long long getnum();

返回分子的值。

long long getden();

返回分母的值。

void setnum(long long num);

接受一个参数，并将其赋给分子（自动约分）。

void setden(long long den);

接受一个非0参数，并将其赋给分母（自动约分）（若参数为0，则不会赋给分母，并在标准输出流中输出错误信息："False,the denominator == 0!!!"）。

数据成员

分子：long long numerator;

分母：long long denominator;

静态成员函数

static long long MCF(long long a, long long b);

此函数接受两个long long型参数，并返回一个值等于他们的最大公因数的long long型值。如fraction：：MCF（2,4）的值为2。

注意事项

　　使用fraction时的一切有关代码中的fraction都可以简写为fac，二者完全等价。

　　分数类的头文件与使用它的源代码文件保存在同一目录下时，必须先编译一下头文件，然后再编译源代码文件，否则会有编译错误，编译后的头文件如果被更改或转移到另一目录下后也必须重新编译，否则会有编译错误！！！

后记

　　此为原创文章，未经允许，严禁转载！！！（在评论区或私信中跟我声明后可以转载，但必须说明出处）