写了一个分数类

永恒的蓝色梦想

1. #pragma once
   
2. #include<cmath>
   
3. #include<iostream>
   
4. 
   
5. 
   
6. 
   
7. namespace std {
   
8.     using namespace std;
   
9.     typedef long long ll;
   
10. 
    
11. 
    
12. 
    
13.     ll gcd(ll a, ll b) {
    
14.         ll c;
    
15.         while (b) {
    
16.             c = a % b;
    
17.             a = b;
    
18.             b = c;
    
19.         }
    
20.         return a;
    
21.     }
    
22. 
    
23. 
    
24. 
    
25.     class fraction {
    
26.         /*
    
27.         注意：
    
28.             分子或分母可能会溢出
    
29.             溢出后的结果是未定义的
    
30.             分母为0的分数是 NaN(Not a Number)
    
31.             Nan 和 其他数 == 永远返回 false，!=永远返回 true
    
32.             对 NaN 运算的结果是未定义的
    
33.         */
    
34.     private:
    
35.         ll nume, deno;
    
36. 
    
37.     public:
    
38.         fraction(ll a = 0, ll b = 1, bool reduction = true) {
    
39.             if (reduction) {
    
40.                 ll temp = gcd(a, b);
    
41.                 if (b < 0) {
    
42.                     this->nume = -a / temp;
    
43.                     this->deno = -b / temp;
    
44.                 }
    
45.                 else {
    
46.                     this->nume = a / temp;
    
47.                     this->deno = b / temp;
    
48.                 }
    
49.             }
    
50.             else if (b < 0) {
    
51.                 this->nume = -a;
    
52.                 this->deno = -b;
    
53.             }
    
54.             else {
    
55.                 this->nume = a;
    
56.                 this->deno = b;
    
57.             }
    
58.         }
    
59. 
    
60.         fraction(fraction a, fraction b) {
    
61.             *this = a / b;
    
62.         }
    
63. 
    
64.         fraction(fraction a, ll b) {
    
65.             ll temp = gcd(a.deno, b);
    
66.             this->nume = b / temp * a.nume;
    
67.             this->deno = a.deno / temp;
    
68.         }
    
69. 
    
70.         fraction(ll a, fraction b) {
    
71.             ll temp = gcd(a, b.nume);
    
72.             this->nume = a / temp * b.deno;
    
73.             this->deno = b.nume / temp;
    
74.         }
    
75. 
    
76. 
    
77.         fraction operator+() {
    
78.             return fraction(*this);
    
79.         }
    
80. 
    
81.         fraction operator+(fraction other) {
    
82.             ll temp = gcd(this->deno, other.deno), a = this->deno / temp, b = other.deno / temp;
    
83.             return fraction(this->nume * b + other.nume * a, a * b);
    
84.         }
    
85. 
    
86. 
    
87.         fraction operator-() {
    
88.             return fraction(-this->nume, this->deno);
    
89.         }
    
90. 
    
91.         fraction operator-(fraction other) {
    
92.             ll temp = gcd(this->deno, other.deno), a = this->deno / temp, b = other.deno / temp;
    
93.             return fraction(this->nume * b - other.nume * a, a * b);
    
94.         }
    
95. 
    
96. 
    
97.         fraction operator*(fraction other) {
    
98.             ll a = gcd(this->nume, other.deno), b = gcd(this->deno, other.nume);
    
99. 
    
100.             return fraction((this->nume / a) * (other.nume / b),
     
101.                 (this->deno / b) * (other.deno / a));
     
102.         }
     
103. 
     
104. 
     
105.         fraction operator/(fraction other) {
     
106.             ll a = gcd(this->nume, other.nume), b = gcd(this->deno, other.deno);
     
107. 
     
108.             return fraction((this->nume / a) * (other.deno / b),
     
109.                 (this->deno / b) * (other.nume / a),
     
110.                 false);
     
111.         }
     
112. 
     
113. 
     
114.         fraction operator%(fraction other) {
     
115.             ll temp = gcd(this->deno, other.deno), a = this->deno / temp, b = other.deno / temp;
     
116.             return fraction((this->nume * b) % (other.nume * a), a * b);
     
117.         }
     
118. 
     
119. 
     
120.         bool operator<(fraction other) {
     
121.             ll temp = gcd(this->deno, other.deno);
     
122.             return other.deno / temp * this->nume < this->deno / temp * other.nume;
     
123.         }
     
124. 
     
125. 
     
126.         bool operator>(fraction other) {
     
127.             ll temp = gcd(this->deno, other.deno);
     
128.             return other.deno / temp * this->nume > this->deno / temp * other.nume;
     
129.         }
     
130. 
     
131. 
     
132.         bool operator<=(fraction other) {
     
133.             ll temp = gcd(this->deno, other.deno);
     
134.             return other.deno / temp * this->nume <= this->deno / temp * other.nume;
     
135.         }
     
136. 
     
137. 
     
138.         bool operator>=(fraction other) {
     
139.             ll temp = gcd(this->deno, other.deno);
     
140.             return other.deno / temp * this->nume >= this->deno / temp * other.nume;
     
141.         }
     
142. 
     
143. 
     
144.         bool operator==(fraction other) {
     
145.             return this->deno && other.deno ? this->nume == other.nume && this->deno == other.deno : false;
     
146.         }
     
147. 
     
148. 
     
149.         bool operator!=(fraction other) {
     
150.             return this->deno && other.deno ? this->nume != other.nume && this->deno != other.deno : true;
     
151.         }
     
152. 
     
153. 
     
154.         operator bool() {
     
155.             return this->deno && this->nume;
     
156.         }
     
157. 
     
158. 
     
159.         operator ll() {
     
160.             return this->nume / this->deno;
     
161.         }
     
162. 
     
163. 
     
164.         operator double() {
     
165.             return double(this->nume) / this->deno;
     
166.         }
     
167. 
     
168. 
     
169.         ll denominator() {
     
170.             return this->deno;
     
171.         }
     
172. 
     
173. 
     
174.         ll numerator() {
     
175.             return this->nume;
     
176.         }
     
177. 
     
178. 
     
179.         static bool isnan(fraction& other) {
     
180.             return !other.deno;
     
181.         }
     
182. 
     
183. 
     
184.         static bool isnumber(fraction& other) {
     
185.             return other.deno;
     
186.         }
     
187. 
     
188. 
     
189.         friend ostream& operator<<(ostream& out, fraction other);
     
190.         friend istream& operator>>(istream& in, fraction& other);
     
191.         /*static double sqrt(fraction other) {
     
192.             return std::sqrt(double(other.nume) * other.deno) / other.deno;
     
193.         }
     
194. 
     
195. 
     
196.         static double cbrt(fraction other) {
     
197.             return std::cbrt(double(other.nume) * other.deno) / other.deno;
     
198.         }
     
199. 
     
200. 
     
201.         static fraction from_double(double other) {
     
202. 
     
203.         }*/
     
204.     };
     
205. 
     
206. 
     
207. 
     
208.     ostream& operator<<(ostream& out, fraction other) {
     
209.         return other.deno ? out << other.nume << '/' << other.deno : out << "NaN";
     
210.     }
     
211. 
     
212. 
     
213. 
     
214.     istream& operator>>(istream& in, fraction& other) {
     
215.         char temp;
     
216.         return in >> other.nume >> temp >> other.deno;
     
217.     }
     
218. }

复制代码

比起 ratio 的优点可能只有能用运算符了吧
目前这个类还有不少缺陷，希望各位大佬可以多包涵，多提建议，多指教！

_2_

应该是 C++
对不起我都看不懂