C++分數類

本文轉載自查看原文 2019-07-25 18:41 1370 作品

引言

我們說，編程語言的精髓在於封裝，而面向對象語言完勝面向過程語言的原因就是具有更好的可封裝性，而C++就是這樣的一種多范型語言，常用而復雜的工作完全不必在每一份源文件中重敲，就好像我們不需要自己手寫printf()和scanf()一樣，自建一個屬於自己的頭文件，可以為編程提供很大的幫助，我今天就要推薦一下我自己原創的分數類（實際上C++STL庫有分數類，只是性能很低，而且使用極其不方便，而我的這個分數類具有很多前者不具備的優點，而且頗具工程碼風，易於理解與更新）。

注：此為原創文章，轉載則務必說明原出處。

Code

將下面的代碼存入一個名為fraction.h文件中，並在同目錄下的源文件中加上：#include“fraction”即可使用該分數類（使用方法見后面）。

或是在IDE存放頭文件的目錄下添加一個名為fraction.h的文件，放入該代碼並編譯，然后便可在該電腦的任何地方創建.cpp文件，並用#include <fraction>包含該文件。

  1 //拱大塏原創
  2 //分數類實現~~~0.8.5
  3 //fraction:分數 
  4 //numerator:分子
  5 //denominator:分母
  6 //輸入分數時請以回車結尾
  7 //輸入部分如含有空格，則空格后面的部分會被忽略 
  8 //fraction可縮寫為fac，計算機可以識別
  9 
 10 #include <iostream>
 11 #include <cmath>
 12 
 13 #ifndef __fraction_h_ 
 14 #define __fraction_h_
 15 
 16 using namespace std;
 17 
 18 namespace std
 19 { 
 20 
 21 //分數類 
 22 class fraction
 23 {
 24 public:
 25     static long long MCF(long long a, long long b);
 26     
 27     friend ostream& operator<< (ostream& os,const fraction& the_fraction);
 28     friend istream& operator>> (istream& is,fraction& the_fraction);
 29     
 30     friend fraction operator+  (const fraction& the_fraction_a,const fraction& the_fraction_b);
 31     friend fraction operator-  (const fraction& the_fraction_a,const fraction& the_fraction_b);
 32     friend fraction operator*  (const fraction& the_fraction_a,const fraction& the_fraction_b);
 33     friend fraction operator/  (const fraction& the_fraction_a,const fraction& the_fraction_b);
 34     friend fraction operator+= (fraction& the_fraction_a,const fraction& the_fraction_b);
 35     friend fraction operator-= (fraction& the_fraction_a,const fraction& the_fraction_b);
 36     friend fraction operator*= (fraction& the_fraction_a,const fraction& the_fraction_b);
 37     friend fraction operator/= (fraction& the_fraction_a,const fraction& the_fraction_b);
 38     friend fraction operator-  (const fraction& the_fraction);
 39     friend fraction operator++ (fraction& the_fraction); 
 40     friend fraction operator++ (fraction& the_fraction,int);
 41     friend fraction operator-- (fraction& the_fraction);
 42     friend fraction operator-- (fraction& the_fraction,int);
 43     
 44     friend bool operator>  (fraction& the_fraction_a,const fraction& the_fraction_b);
 45     friend bool operator<  (fraction& the_fraction_a,const fraction& the_fraction_b);
 46     friend bool operator>= (fraction& the_fraction_a,const fraction& the_fraction_b);
 47     friend bool operator<= (fraction& the_fraction_a,const fraction& the_fraction_b);
 48     friend bool operator== (fraction& the_fraction_a,const fraction& the_fraction_b);
 49     friend bool operator!= (fraction& the_fraction_a,const fraction& the_fraction_b);
 50     
 51     fraction();
 52     fraction(long long the_numerator);
 53     fraction(long long the_numerator,long long the_denominator);
 54     fraction(fraction the_fraction_a,fraction the_fraction_b);
 55     
 56     double decimal();
 57     long long getnum();
 58     long long getden();
 59     void setnum(long long num);
 60     void setden(long long den);
 61     
 62 private: 
 63     long long numerator;
 64     long long denominator; 
 65     
 66 };
 67 
 68 
 69 
 70 long long fraction::MCF(long long a, long long b)
 71 {
 72     return a==0? b:MCF(b%a,a);
 73 }
 74 
 75 
 76 
 77 ostream& operator<< (ostream& os,const fraction& the_fraction)
 78 {
 79     bool book=the_fraction.numerator>=0&&the_fraction.denominator>=0||the_fraction.numerator<0&&the_fraction.denominator<0;
 80     if(book==false)
 81         os<<"(-";
 82     if(the_fraction.denominator!=1)
 83         os<<abs(the_fraction.numerator)<<"/"<<abs(the_fraction.denominator);
 84     else
 85         os<<abs(the_fraction.numerator);
 86     if(book==false)
 87         os<<")";
 88     return os;
 89 }
 90 
 91 istream& operator>> (istream& is,fraction& the_fraction)
 92 {
 93     char input[100];
 94     char ch;
 95     bool mid=false;
 96     bool is_pt=true;
 97     the_fraction.numerator=the_fraction.denominator=0;
 98     cin>>input;
 99     for(int i=0;;i++)
100     {    
101         ch=input[i];
102         if(ch=='\0')
103             break;
104         if(ch=='-')
105         {
106             is_pt=!is_pt;
107             continue;
108         }
109         if(ch=='/')
110         {
111             mid=true;
112             continue;
113         }
114         if(mid==false)
115             the_fraction.numerator=the_fraction.numerator*10+(ch-'0');
116         else
117             the_fraction.denominator=the_fraction.denominator*10+(ch-'0');
118     }
119     if(mid==false)
120         the_fraction.denominator=1;
121     if(the_fraction.denominator==0)
122     {
123         cout<<"False,the denominator == 0!!!";
124         return is;
125     }    
126     long long mcf=fraction::MCF(the_fraction.numerator,the_fraction.denominator);
127     the_fraction.numerator/=mcf;
128     the_fraction.denominator/=mcf;
129     if(!is_pt)
130         the_fraction.numerator=-the_fraction.numerator;
131     return is;
132 }
133 
134 
135 
136 fraction operator+ (const fraction& the_fraction_a,const fraction& the_fraction_b)
137 {
138     long long the_numerator=the_fraction_a.numerator*the_fraction_b.denominator+the_fraction_b.numerator*the_fraction_a.denominator;
139     long long the_denominator=the_fraction_a.denominator*the_fraction_b.denominator;
140     return fraction(the_numerator,the_denominator);
141 }
142 
143 fraction operator- (const fraction& the_fraction_a,const fraction& the_fraction_b)
144 {
145     long long the_numerator=the_fraction_a.numerator*the_fraction_b.denominator-the_fraction_b.numerator*the_fraction_a.denominator;
146     long long the_denominator=the_fraction_a.denominator*the_fraction_b.denominator;
147     return fraction(the_numerator,the_denominator);
148 }
149 fraction operator* (const fraction& the_fraction_a,const fraction& the_fraction_b)
150 {
151     long long the_numerator=the_fraction_a.numerator*the_fraction_b.numerator;
152     long long the_denominator=the_fraction_a.denominator*the_fraction_b.denominator;
153     long long mcf=fraction::MCF(the_numerator,the_denominator);
154     the_numerator/=mcf;
155     the_denominator/=mcf;
156     fraction the_fraction(the_numerator,the_denominator);
157     return the_fraction;
158 }
159 
160 fraction operator/(const fraction& the_fraction_a,const fraction& the_fraction_b)
161 {
162     return the_fraction_a*fraction(the_fraction_b.denominator,the_fraction_b.numerator);
163 }
164 
165 fraction operator+= (fraction& the_fraction_a,const fraction& the_fraction_b)
166 {
167     return the_fraction_a=the_fraction_a+the_fraction_b;
168 }
169 
170 fraction operator-= (fraction& the_fraction_a,const fraction& the_fraction_b)
171 {
172     return the_fraction_a=the_fraction_a-the_fraction_b;
173 }
174 
175 fraction operator*= (fraction& the_fraction_a,const fraction& the_fraction_b)
176 {
177     return the_fraction_a=the_fraction_a*the_fraction_b;
178 }
179 
180 fraction operator/= (fraction& the_fraction_a,const fraction& the_fraction_b)
181 {
182     return the_fraction_a=the_fraction_a/the_fraction_b;
183 }
184 
185 fraction operator-  (const fraction& the_fraction)
186 {
187     return 0-the_fraction;
188 }
189 
190 fraction operator++ (fraction& the_fraction)
191 {
192     the_fraction=the_fraction+1;
193     return the_fraction;
194 }
195 fraction operator++ (fraction& the_fraction,int)
196 {
197     the_fraction=the_fraction+1;
198     return the_fraction-1;
199 }
200 fraction operator-- (fraction& the_fraction)
201 {
202     the_fraction=the_fraction-1;
203     return the_fraction;
204 }
205 fraction operator-- (fraction& the_fraction,int)
206 {
207     the_fraction=the_fraction-1;
208     return the_fraction+1;
209 }
210 
211 
212 
213 bool operator>  (fraction& the_fraction_a,const fraction& the_fraction_b)
214 {
215     return the_fraction_a.numerator*the_fraction_b.denominator>the_fraction_b.numerator*the_fraction_a.denominator;
216 }
217 bool operator<  (fraction& the_fraction_a,const fraction& the_fraction_b)
218 {
219     return the_fraction_a.numerator*the_fraction_b.denominator<the_fraction_b.numerator*the_fraction_a.denominator;
220 }
221 bool operator>= (fraction& the_fraction_a,const fraction& the_fraction_b)
222 {
223     return the_fraction_a.numerator*the_fraction_b.denominator>=the_fraction_b.numerator*the_fraction_a.denominator;
224 }
225 bool operator<= (fraction& the_fraction_a,const fraction& the_fraction_b)
226 {
227     return the_fraction_a.numerator*the_fraction_b.denominator<=the_fraction_b.numerator*the_fraction_a.denominator;
228 }
229 bool operator== (fraction& the_fraction_a,const fraction& the_fraction_b)
230 {
231     return the_fraction_a.numerator*the_fraction_b.denominator==the_fraction_b.numerator*the_fraction_a.denominator;
232 }
233 bool operator!= (fraction& the_fraction_a,const fraction& the_fraction_b)
234 {
235     return the_fraction_a.numerator*the_fraction_b.denominator!=the_fraction_b.numerator*the_fraction_a.denominator;
236 }
237 
238 
239 
240 fraction::fraction()
241 {
242     numerator=0;
243     denominator=1;
244 }
245 
246 fraction::fraction(long long the_numerator)
247 {
248     numerator=the_numerator;
249     denominator=1;
250 }
251 
252 fraction::fraction(long long the_numerator,long long the_denominator)
253 {    
254     long long mcf=fraction::MCF(the_numerator,the_denominator);
255     numerator=the_numerator/mcf;
256     denominator=the_denominator/mcf;
257 }
258 
259 fraction::fraction(fraction the_fraction_a,fraction the_fraction_b)
260 {
261     long long the_numerator=the_fraction_a.numerator*the_fraction_b.denominator;
262     long long the_denominator=the_fraction_a.denominator*the_fraction_b.numerator;
263     long long mcf=fraction::MCF(the_numerator,the_denominator);
264     numerator=the_numerator/mcf;
265     denominator=the_denominator/mcf;
266 }
267 
268 double fraction::decimal()
269 {
270     return 1.0*numerator/denominator;
271 }
272 
273 long long fraction::getnum()
274 {
275     return numerator;
276 }
277 long long fraction::getden()
278 {
279     return denominator;
280 }
281 void fraction::setnum(long long num)
282 {
283     numerator=num;
284     long long mcf=fraction::MCF(numerator,denominator);
285     numerator/=mcf;
286     denominator/=mcf;
287 }
288 void fraction::setden(long long den)
289 {
290     if(den!=0)
291     {
292         denominator=den;
293         long long mcf=fraction::MCF(numerator,denominator);
294         numerator/=mcf;
295         denominator/=mcf;
296     }
297     else
298     {
299         cout<<"False,the denominator == 0!!!";
300     }
301 }
302 
303 typedef fraction fac;
304 
305 }
306 
307 #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，二者完全等價。

　　分數類的頭文件與使用它的源代碼文件保存在同一目錄下時，必須先編譯一下頭文件，然后再編譯源代碼文件，否則會有編譯錯誤，編譯后的頭文件如果被更改或轉移到另一目錄下后也必須重新編譯，否則會有編譯錯誤！！！

后記

　　此為原創文章，未經允許，嚴禁轉載！！！（在評論區或私信中跟我聲明后可以轉載，但必須說明出處）

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 C++,分數線划定 java的分數類 C++：類的組合創建自己的C++類 C++模板類 C++類模板 C++類的內存分配 C++的UML類圖 c++ 注冊類到 lua C++ string 類詳解