大数计算加减法

bin554385863

lnum.h
目前只支持同号加法

1. #ifndef LNUM_H
   
2. #define LNUM_H
   
3. #include <iostream>
   
4. #include <string>
   
5. #include <vector>
   
6. using std::istream;
   
7. using std::ostream;
   
8. using std::string;
   
9. using std::vector;
   
10. class lnum
    
11. {
    
12.     struct attr
    
13.     {
    
14.         int sign = 1;          //符号;
    
15.         size_t dpsize = 0;     //小数位;
    
16.         size_t prec = 0;       //精度
    
17.         size_t nsize = 1;      //有效位数
    
18.         string str = "0";      //过渡字符串
    
19.         vector<int> vec = {0}; //数组;
    
20.     };
    
21.     struct align
    
22.     {
    
23.         vector<int> first;
    
24. 
    
25.         vector<int> second;
    
26.     };
    
27. 
    
28. private:
    
29.     //小数精度;
    
30.     static size_t precision;
    
31.     //数据;
    
32.     attr num;
    
33.     //str to attr
    
34.     const attr StrToAttr(const string &str) const;
    
35.     //attr to str
    
36.     const string AttrToStr() const;
    
37.     //进1
    
38.     lnum &Carry();
    
39.     //借1
    
40.     vector<int> Borrow() const;
    
41.     //对齐
    
42.     const align AlignVec(const vector<int> &m, const vector<int> &n) const;
    
43.     //反转正负
    
44.     vector<int> Negative() const;
    
45.     //clear zero vec
    
46.     lnum &ClearZeroVec();
    
47.     //vec to str
    
48.     lnum &VecToStr();
    
49. 
    
50. public:
    
51.     lnum(const char *cstr = "0") : num(StrToAttr(cstr))
    
52.     {
    
53.     }
    
54.     lnum(const string &str) : num(StrToAttr(str)) {}
    
55.     lnum(const lnum &l) : num(l.num) {}
    
56.     //------------------------------------------------------------------
    
57.     //设置精度
    
58.     static void SetPrecision(const size_t i);
    
59.     //展示信息
    
60.     void Showinfo() const;
    
61.     //>
    
62.     const bool operator>(const lnum &l) const;
    
63.     //<
    
64.     const bool operator<(const lnum &l) const;
    
65.     //==
    
66.     const bool operator==(const lnum &l) const;
    
67.     //>=
    
68.     const bool operator>=(const lnum &l) const;
    
69.     //<=
    
70.     const bool operator<=(const lnum &l) const;
    
71.     //+
    
72.     const lnum operator+(const lnum &l) const;
    
73.     //-
    
74.     const lnum operator-(const lnum &l) const;
    
75.     //>>
    
76.     friend istream &operator>>(istream &is, const lnum &l);
    
77.     //<<
    
78.     friend ostream &operator<<(ostream &os, const lnum &l);
    
79. };
    
80. size_t lnum::precision = 0;
    
81. #endif

复制代码

lnum.cpp

1. #include "E:\Users\admin\Documents\VScode\Code\My Class\shape.cpp\lnum\lnum.h"
   
2. //str to attr
   
3. const lnum::attr lnum::StrToAttr(const string &str) const
   
4. {
   
5.     attr n;
   
6.     n.prec = precision;
   
7.     n.str = str;
   
8.     string &nstr = n.str;
   
9.     if (nstr[0] == '-')
   
10.     {
    
11.         nstr.erase(0, 1);
    
12.     }
    
13.     if (int(nstr.find('.')) != -1)
    
14.     {
    
15.         nstr.erase(nstr.find('.'), 1);
    
16.     }
    
17.     if (nstr == string(nstr.size(), '0'))
    
18.     {
    
19.         nstr.clear();
    
20.         nstr.push_back('0');
    
21.     }
    
22.     else if (nstr != string(nstr.size(), '0'))
    
23.     {
    
24.         size_t s = nstr.size(), i = 0;
    
25.         if (str[0] == '-')
    
26.         {
    
27.             n.sign = -1;
    
28.         }
    
29.         if (int(str.find('.')) != -1)
    
30.         {
    
31.             n.dpsize = str.size() - str.find('.') - 1;
    
32.             if (nstr[0] == '0')
    
33.             {
    
34. 
    
35.                 for (; i < s; i++)
    
36.                 {
    
37.                     if (nstr[i] != '0')
    
38.                     {
    
39.                         break;
    
40.                     }
    
41.                 }
    
42.                 if (i >= s - n.dpsize)
    
43.                 {
    
44.                     nstr.erase(0, s - n.dpsize - 1);
    
45.                 }
    
46.                 else if (i < s - n.dpsize)
    
47.                 {
    
48.                     nstr.erase(0, i);
    
49.                 }
    
50.             }
    
51.         }
    
52.         else
    
53.         {
    
54.             if (nstr[0] == '0')
    
55.             {
    
56.                 for (i = 0; i < s; i++)
    
57.                 {
    
58.                     if (nstr[i] != '0')
    
59.                     {
    
60.                         break;
    
61.                     }
    
62.                 }
    
63.                 nstr.erase(0, i);
    
64.             }
    
65.         }
    
66.         if (n.prec > n.dpsize)
    
67.         {
    
68.             nstr.insert(nstr.end(), n.prec - n.dpsize, '0');
    
69.         }
    
70.         else if (n.prec < n.dpsize)
    
71.         {
    
72.             nstr.erase(nstr.size() - (n.dpsize - n.prec));
    
73.             n.dpsize = n.prec;
    
74.         }
    
75.         n.vec.clear();
    
76.         for (char c : nstr)
    
77.         {
    
78.             n.vec.push_back(c - 48);
    
79.         }
    
80.         n.nsize = nstr.size();
    
81.     }
    
82.     return n;
    
83. }
    
84. //attr to str
    
85. const string lnum::AttrToStr() const
    
86. {
    
87.     string str = num.str;
    
88.     const size_t &prec = num.prec, &dpsize = num.dpsize;
    
89.     if (str.size() != 1 && prec != 0)
    
90.     {
    
91.         if (dpsize == prec)
    
92.         {
    
93.             str.insert(str.size() - prec, 1, '.');
    
94.         }
    
95.         else if (dpsize < prec && dpsize != 0)
    
96.         {
    
97.             str.erase(str.size() - (prec - dpsize));
    
98.             str.insert(str.size() - dpsize, 1, '.');
    
99.         }
    
100.         else if (dpsize == 0)
     
101.         {
     
102.             str.erase(str.size() - prec);
     
103.         }
     
104.     }
     
105.     if (num.sign == -1)
     
106.     {
     
107.         str.insert(0, 1, '-');
     
108.     }
     
109.     return str;
     
110. }
     
111. //进1
     
112. lnum &lnum::Carry()
     
113. {
     
114.     vector<int> &v = num.vec;
     
115.     v.insert(v.begin(), 1, 0);
     
116.     size_t s = v.size();
     
117.     for (size_t i = s - 1; i > 0; i--)
     
118.     {
     
119.         int t = v[i];
     
120.         v[i] = t % 10;
     
121.         v[i - 1] += t / 10;
     
122.     }
     
123.     return *this;
     
124. }
     
125. //借1
     
126. vector<int> lnum::Borrow() const
     
127. {
     
128.     vector<int> t = num.vec;
     
129.     size_t s = t.size();
     
130.     for (size_t i = 1; i < s; i++)
     
131.     {
     
132.         t[i - 1] -= 1;
     
133.         t[i] += 10;
     
134.     }
     
135.     return t;
     
136. }
     
137. //对齐
     
138. const lnum::align lnum::AlignVec(const vector<int> &m, const vector<int> &n) const
     
139. {
     
140.     align agn;
     
141.     vector<int> &fst = agn.first, &sec = agn.second;
     
142.     fst = m, sec = n;
     
143.     size_t fsize = fst.size(), ssize = sec.size();
     
144.     if (fsize < ssize)
     
145.     {
     
146.         fst.insert(fst.begin(), ssize - fsize, 0);
     
147.     }
     
148.     else if (fsize > ssize)
     
149.     {
     
150.         sec.insert(sec.begin(), fsize - ssize, 0);
     
151.     }
     
152.     return agn;
     
153. }
     
154. //反转正负
     
155. vector<int> lnum::Negative() const
     
156. {
     
157.     auto r = num.vec;
     
158.     for (int &i : r)
     
159.     {
     
160.         i = -1;
     
161.     }
     
162.     return r;
     
163. }
     
164. //clear zero vec
     
165. lnum &lnum::ClearZeroVec()
     
166. {
     
167.     const size_t &prec = num.prec;
     
168.     vector<int> &v = num.vec;
     
169.     if (v == vector<int>(v.size(), 0))
     
170.     {
     
171.         v.clear();
     
172.         v.push_back(0);
     
173.     }
     
174.     else if (v[0] == 0)
     
175.     {
     
176.         size_t s = v.size(), i = 0;
     
177.         if (prec != 0)
     
178.         {
     
179.             
     
180.             for (; i < s; i++)
     
181.             {
     
182.                 if (v[i] != 0)
     
183.                 {
     
184.                     break;
     
185.                 }
     
186.             }
     
187.             if (i >= s - prec)
     
188.             {
     
189.                 v.erase(v.begin(), v.begin() + (s - prec - 1));
     
190.             }
     
191.             else if (i < s - prec)
     
192.             {
     
193.                 v.erase(v.begin(), v.begin() + i);
     
194.             }
     
195.         }
     
196.         else
     
197.         {
     
198.             for ( i = 0; i < s; i++)
     
199.             {
     
200.                 if (v[i] != 0)
     
201.                 {
     
202.                     break;
     
203.                 }
     
204.             }
     
205.             v.erase(v.begin(), v.begin() + i);
     
206.         }
     
207.         
     
208.     }
     
209.     return *this;
     
210. }
     
211. //vec to str
     
212. lnum &lnum::VecToStr()
     
213. {
     
214.     num.str.clear();
     
215.     for (int i : num.vec)
     
216.     {
     
217.         num.str.push_back(i + 48);
     
218.     }
     
219.     return *this;
     
220. }
     
221. //------------------------------------------------------------------------
     
222. //设置精度
     
223. void lnum::SetPrecision(const size_t i)
     
224. {
     
225.     lnum::precision = i;
     
226. }
     
227. //展示信息
     
228. void lnum::Showinfo() const
     
229. {
     
230.     std::cout << "有效数位: ";
     
231.     for (int i : num.vec)
     
232.     {
     
233.         std::cout << i << " ";
     
234.     }
     
235.     std::cout << std::endl;
     
236.     std::cout << "正负符号: " << num.sign << "\n"
     
237.               << "小数位数: " << num.dpsize << "\n"
     
238.               << "小数精度: " << num.prec << "\n"
     
239.               << "有效位数: " << num.nsize << std::endl;
     
240. }
     
241. //>
     
242. const bool lnum::operator>(const lnum &l) const
     
243. {
     
244.     bool f = true;
     
245.     align agn = AlignVec(num.vec, l.num.vec);
     
246.     const vector<int> &fst = agn.first, &sec = agn.second;
     
247.     if (num.sign < l.num.sign)
     
248.     {
     
249.         f = false;
     
250.     }
     
251.     if (num.sign == l.num.sign)
     
252.     {
     
253.         f = fst > sec;
     
254.         if (num.sign == -1)
     
255.         {
     
256.             f = !f;
     
257.         }
     
258.     }
     
259.     return f;
     
260. }
     
261. //<
     
262. const bool lnum::operator<(const lnum &l) const
     
263. {
     
264.     bool f = true;
     
265.     align agn = AlignVec(num.vec, l.num.vec);
     
266.     const vector<int> &fst = agn.first, &sec = agn.second;
     
267.     if (num.sign > l.num.sign)
     
268.     {
     
269.         f = false;
     
270.     }
     
271.     if (num.sign == l.num.sign)
     
272.     {
     
273.         f = fst < sec;
     
274.         if (num.sign == -1)
     
275.         {
     
276.             f = !f;
     
277.         }
     
278.     }
     
279.     return f;
     
280. }
     
281. //==
     
282. const bool lnum::operator==(const lnum &l) const
     
283. {
     
284.     align agn = AlignVec(num.vec, l.num.vec);
     
285.     const vector<int> &fst = agn.first, &sec = agn.second;
     
286.     return fst == sec && num.sign == l.num.sign;
     
287. }
     
288. //>=
     
289. const bool lnum::operator>=(const lnum &l) const
     
290. {
     
291.     return !(*this < l);
     
292. }
     
293. //<=
     
294. const bool lnum::operator<=(const lnum &l) const
     
295. {
     
296.     return !(*this > l);
     
297. }
     
298. //+
     
299. const lnum lnum::operator+(const lnum &l) const
     
300. {
     
301. 
     
302.     lnum r;
     
303.     attr &lr = r.num;
     
304.     const size_t &prec = num.prec, &dpsize = num.dpsize, &ldps = l.num.dpsize;
     
305.     if ((num.vec == vector<int>(1, 0)) && (l.num.vec == vector<int>(1, 0)))
     
306.     {
     
307.         lr.prec = num.prec;
     
308.     }
     
309.     else if ((num.vec != vector<int>(1, 0)) || (l.num.vec != vector<int>(1, 0)))
     
310.     {
     
311.         const align &agn = AlignVec(num.vec, l.num.vec);
     
312.         const vector<int> &fst = agn.first,
     
313.                           &sec = agn.second,
     
314.                           &tvec = this->num.vec,
     
315.                           &lvec = l.num.vec;
     
316.         lr.prec = prec;
     
317.         lr.dpsize = dpsize >= ldps ? dpsize : ldps;
     
318.         if (num.sign == l.num.sign)
     
319.         {
     
320.             lr.sign = num.sign;
     
321.             if (((tvec == vector<int>(1, 0)) && (lvec != vector<int>(1, 0))) ||((tvec != vector<int>(1, 0)) && (lvec == vector<int>(1, 0))))
     
322.             {
     
323.                 lr.vec = num.nsize > l.num.nsize ? tvec : lvec;
     
324.             }
     
325.             else if ((tvec != vector<int>(1, 0)) && (lvec != vector<int>(1, 0)))
     
326.             {
     
327.                 size_t s = fst.size();
     
328.                 lr.vec = fst;
     
329.                 for (size_t i = 0; i < s; i++)
     
330.                 {
     
331.                     lr.vec[i] += sec[i];
     
332.                 }
     
333.             }
     
334.             r.Carry().ClearZeroVec().VecToStr();
     
335.             lr.nsize = lr.vec.size();
     
336.         }
     
337.         else
     
338.         {
     
339.             r = *this - l;
     
340.         }
     
341.     }
     
342.     return r;
     
343. }
     
344. //-
     
345. const lnum lnum::operator-(const lnum &l) const
     
346. {
     
347. }
     
348. //>>
     
349. istream &operator>>(istream &is, lnum &l)
     
350. {
     
351.     string str;
     
352.     (is >> str).get();
     
353.     l = str;
     
354.     return is;
     
355. }
     
356. //<<
     
357. ostream &operator<<(ostream &os, const lnum &l)
     
358. {
     
359.     os << l.AttrToStr();
     
360.     return os;
     
361. }
     

复制代码

lnum_test.cpp

1. #include "E:\Users\admin\Documents\VScode\Code\My Class\shape.cpp\lnum\lnum.cpp"
   
2. int main(int argc, char const *argv[])
   
3. {
   
4.     lnum::SetPrecision(3);
   
5.     lnum a, b, c;
   
6.     int i = 0;
   
7.     while (i != 5)
   
8.     {
   
9.         std::cout << "input data\n";
   
10.         std::cin >> a >> b;
    
11.         std::cout << "a = " << a << "  "
    
12.                   << "b = " << b << "\n"
    
13.                   << "a + b = " << (a + b) << std::endl;
    
14.                   std::cout << std::endl;
    
15.         i++;
    
16.     }
    
17.    
    
18.     return 0;
    
19. }
    

复制代码

======================================================
Microsoft Windows [版本 10.0.18363.535]
(c) 2019 Microsoft Corporation。保留所有权利。

E:\Users\admin\Documents\VScode\Code>c:\Users\admin\.vscode\extensions\ms-vscode.cpptools-0.26.2\debugAdapters\bin\WindowsDebugLauncher.exe --stdin=Microsoft-MIEngine-In-hjg4v2n2.0lr --stdout=Microsoft-MIEngine-Out-ggdaz51y.hrw --stderr=Microsoft-MIEngine-Error-1w25bxep.ub3 --pid=Microsoft-MIEngine-Pid-pa4lnrzg.3fq --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi

E:\Users\admin\Documents\VScode\Code>cmd /C "c:\Users\admin\.vscode\extensions\ms-vscode.cpptools-0.26.2\debugAdapters\bin\WindowsDebugLauncher.exe --stdin=Microsoft-MIEngine-In-rdahdasn.3vx --stdout=Microsoft-MIEngine-Out-2nxw4ara.tc2 --stderr=Microsoft-MIEngine-Error-b5yp3gag.nte --pid=Microsoft-MIEngine-Pid-twogf14w.0fy --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi "
input data
-999.321 -111.123
a = -999.321  b = -111.123
a + b = -1110.444

input data
123456789
987654321
a = 123456789  b = 987654321
a + b = 1111111110

input data
1111111111111111111111111
3333333333333333333333333
a = 1111111111111111111111111  b = 3333333333333333333333333
a + b = 4444444444444444444444444

input data
999999999999
999999999999
a = 999999999999  b = 999999999999
a + b = 1999999999998

input data
987654321
12345679
a = 987654321  b = 12345679
a + b = 1000000000


E:\Users\admin\Documents\VScode\Code>cmd /C "c:\Users\admin\.vscode\extensions\ms-vscode.cpptools-0.26.2\debugAdapters\bin\WindowsDebugLauncher.exe --stdin=Microsoft-MIEngine-In-dlfxekp3.bym --stdout=Microsoft-MIEngine-Out-jtwn51h5.ubn --stderr=Microsoft-MIEngine-Error-rc5va4if.ni3 --pid=Microsoft-MIEngine-Pid-xrrvgcs4.jrr --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi "
input data
-9999999999999999999999
-9999999999999999999999
a = -9999999999999999999999  b = -9999999999999999999999
a + b = -19999999999999999999998

input data
-99999999999999999999999999999999999999999
-99999999999999999999999999999999999999999
a = -99999999999999999999999999999999999999999  b = -99999999999999999999999999999999999999999
a + b = -199999999999999999999999999999999999999998

input data
9999999999999999999999999999999999999999999999999999
9999999999999999999999999999999999999999999999999999
a = 9999999999999999999999999999999999999999999999999999  b = 9999999999999999999999999999999999999999999999999999
a + b = 19999999999999999999999999999999999999999999999999998

input data
111111111111111111111111111111111111111.1111111111111111111111
99999999999999999999999999999999999.9999999999999999999999
a = 111111111111111111111111111111111111111.111  b = 99999999999999999999999999999999999.999
a + b = 111211111111111111111111111111111111111.110

input data
-1.2366666
-9.3654
a = -1.236  b = -9.365
a + b = -10.601


E:\Users\admin\Documents\VScode\Code>

-------------------------------------------------------------------------------------------------
test.cpp

1. #include "E:\Users\admin\Documents\VScode\Code\My Class\shape.cpp\lnum\lnum.cpp"
   
2. int main(int argc, char const *argv[])
   
3. {
   
4.     lnum::SetPrecision(3);
   
5.     lnum a, b, c;
   
6.     int i = 0;
   
7.     while (i != 5)
   
8.     {
   
9.         std::cout << "input data\n";
   
10.         std::cin >> a >> b;
    
11.         std::cout << std::boolalpha << "a = " << a << "  "
    
12.                   << "b = " << b << "\n"
    
13.                   << "a >= b: " << (a >= b) << "\n"
    
14.                   << "a >  b: " << (a > b) << "\n"
    
15.                   << "a <= b: " << (a <= b) << "\n"
    
16.                   << "a <  b: " << (a < b) << "\n"
    
17.                   << "a == b: " << (a == b);
    
18.         std::cout << std::endl;
    
19.         i++;
    
20.     }
    
21.    
    
22.     return 0;
    
23. }
    

复制代码

================================================
Microsoft Windows [版本 10.0.18363.535]
(c) 2019 Microsoft Corporation。保留所有权利。

E:\Users\admin\Documents\VScode\Code>c:\Users\admin\.vscode\extensions\ms-vscode.cpptools-0.26.2\debugAdapters\bin\WindowsDebugLauncher.exe --stdin=Microsoft-MIEngine-In-zcwtj5dz.rhq --stdout=Microsoft-MIEngine-Out-rmj34qps.1zn --stderr=Microsoft-MIEngine-Error-opbzjopy.skk --pid=Microsoft-MIEngine-Pid-t23shlyh.4d2 --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi
input data
0
0.01
a = 0  b = 0.01
a >= b: false  
a >  b: false  
a <= b: true   
a <  b: true   
a == b: false  
input data     
0
0
a = 0  b = 0
a >= b: true
a >  b: false
a <= b: true
a <  b: false
a == b: true
input data
99999999999999999999999999
66666666666666666666666666
a = 99999999999999999999999999  b = 66666666666666666666666666
a >= b: true
a >  b: true
a <= b: false
a <  b: false
a == b: false
input data
11111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111112
a = 11111111111111111111111111111111111111111111111111  b = 11111111111111111111111111111111111111111111111112
a >= b: false
a >  b: false
a <= b: true
a <  b: true
a == b: false
input data
0.02
0.03
a = 0.02  b = 0.03
a >= b: false
a >  b: false
a <= b: true
a <  b: true
a == b: false

E:\Users\admin\Documents\VScode\Code>

bin554385863

lnum.h

1. #ifndef LNUM_H
   
2. #define LNUM_H
   
3. #include <iostream>
   
4. #include <string>
   
5. #include <vector>
   
6. using std::istream;
   
7. using std::ostream;
   
8. using std::string;
   
9. using std::vector;
   
10. class lnum
    
11. {
    
12.     struct attr
    
13.     {
    
14.         int sign = 1;          //符号;
    
15.         size_t dpsize = 0;     //小数位;
    
16.         size_t prec = 0;       //精度
    
17.         size_t nsize = 1;      //有效位数
    
18.         string str = "0";      //过渡字符串
    
19.         vector<int> vec = {0}; //数组;
    
20.     };
    
21.     struct align
    
22.     {
    
23.         vector<int> first;
    
24. 
    
25.         vector<int> second;
    
26.     };
    
27. 
    
28. private:
    
29.     //小数精度;
    
30.     static size_t precision;
    
31.     //数据;
    
32.     attr num;
    
33.     //str to attr
    
34.     const attr StrToAttr(const string &str) const;
    
35.     //attr to str
    
36.     const string AttrToStr() const;
    
37.     //进1
    
38.     lnum &Carry();
    
39.     //借1
    
40.     void Borrow(vector<int> &v) const;
    
41.     //对齐
    
42.     const align AlignVec(const vector<int> &m, const vector<int> &n) const;
    
43.     //反转正负
    
44.     const lnum Negative() const;
    
45.     //clear zero vec
    
46.     lnum &ClearZeroVec();
    
47.     //vec to str
    
48.     lnum &VecToStr();
    
49. 
    
50. public:
    
51.     lnum(const char *cstr = "0") : num(StrToAttr(cstr)){}
    
52.     lnum(const string &str) : num(StrToAttr(str)) {}
    
53.     lnum(const char c) : num(StrToAttr(string(1, c))) {}
    
54.     lnum(const lnum &l) : num(l.num) {}
    
55.     //------------------------------------------------------------------
    
56.     //设置精度
    
57.     static void SetPrecision(const size_t i);
    
58.     //展示信息
    
59.     void Showinfo() const;
    
60.     //>
    
61.     const bool operator>(const lnum &l) const;
    
62.     //<
    
63.     const bool operator<(const lnum &l) const;
    
64.     //==
    
65.     const bool operator==(const lnum &l) const;
    
66.     //>=
    
67.     const bool operator>=(const lnum &l) const;
    
68.     //<=
    
69.     const bool operator<=(const lnum &l) const;
    
70.     //+
    
71.     const lnum operator+(const lnum &l) const;
    
72.     //-
    
73.     const lnum operator-(const lnum &l) const;
    
74.     //>>
    
75.     friend istream &operator>>(istream &is, const lnum &l);
    
76.     //<<
    
77.     friend ostream &operator<<(ostream &os, const lnum &l);
    
78. };
    
79. size_t lnum::precision = 0;
    
80. #endif

复制代码

lnum.cpp

1. #include "E:\Users\admin\Documents\VScode\Code\My Class\shape.cpp\lnum\lnum.h"
   
2. //str to attr
   
3. const lnum::attr lnum::StrToAttr(const string &str) const
   
4. {
   
5.     attr n;
   
6.     n.prec = precision;
   
7.     n.str = str;
   
8.     string &nstr = n.str;
   
9.     if (nstr[0] == '-')
   
10.     {
    
11.         nstr.erase(0, 1);
    
12.     }
    
13.     if (int(nstr.find('.')) != -1)
    
14.     {
    
15.         nstr.erase(nstr.find('.'), 1);
    
16.     }
    
17.     if (nstr == string(nstr.size(), '0'))
    
18.     {
    
19.         nstr.clear();
    
20.         nstr.push_back('0');
    
21.     }
    
22.     else //if (nstr != string(nstr.size(), '0'))
    
23.     {
    
24.         size_t s = nstr.size(), i = 0;
    
25.         if (str[0] == '-')
    
26.         {
    
27.             n.sign = -1;
    
28.         }
    
29.         if (int(str.find('.')) != -1)
    
30.         {
    
31.             n.dpsize = str.size() - str.find('.') - 1;
    
32.             if (nstr[0] == '0')
    
33.             {
    
34. 
    
35.                 for (; i < s; i++)
    
36.                 {
    
37.                     if (nstr[i] != '0')
    
38.                     {
    
39.                         break;
    
40.                     }
    
41.                 }
    
42.                 if (i >= s - n.dpsize)
    
43.                 {
    
44.                     nstr.erase(0, s - n.dpsize - 1);
    
45.                 }
    
46.                 else if (i < s - n.dpsize)
    
47.                 {
    
48.                     nstr.erase(0, i);
    
49.                 }
    
50.             }
    
51.         }
    
52.         else
    
53.         {
    
54.             if (nstr[0] == '0')
    
55.             {
    
56.                 for (i = 0; i < s; i++)
    
57.                 {
    
58.                     if (nstr[i] != '0')
    
59.                     {
    
60.                         break;
    
61.                     }
    
62.                 }
    
63.                 nstr.erase(0, i);
    
64.             }
    
65.         }
    
66.         if (n.prec > n.dpsize)
    
67.         {
    
68.             nstr.insert(nstr.end(), n.prec - n.dpsize, '0');
    
69.         }
    
70.         else if (n.prec < n.dpsize)
    
71.         {
    
72.             nstr.erase(nstr.size() - (n.dpsize - n.prec));
    
73.             n.dpsize = n.prec;
    
74.         }
    
75.         n.vec.clear();
    
76.         for (char c : nstr)
    
77.         {
    
78.             n.vec.push_back(c - 48);
    
79.         }
    
80.         n.nsize = nstr.size();
    
81.     }
    
82.     return n;
    
83. }
    
84. //attr to str
    
85. const string lnum::AttrToStr() const
    
86. {
    
87.     string str = num.str;
    
88.     const size_t &prec = num.prec, &dpsize = num.dpsize;
    
89.     if (str.size() != 1 && prec != 0)
    
90.     {
    
91.         if (dpsize == prec)
    
92.         {
    
93.             str.insert(str.size() - prec, 1, '.');
    
94.         }
    
95.         else if (dpsize < prec && dpsize != 0)
    
96.         {
    
97.             str.erase(str.size() - (prec - dpsize));
    
98.             str.insert(str.size() - dpsize, 1, '.');
    
99.         }
    
100.         else if (dpsize == 0)
     
101.         {
     
102.             str.erase(str.size() - prec);
     
103.         }
     
104.     }
     
105.     if (num.sign == -1)
     
106.     {
     
107.         str.insert(0, 1, '-');
     
108.     }
     
109.     return str;
     
110. }
     
111. //进1
     
112. lnum &lnum::Carry()
     
113. {
     
114.     vector<int> &v = num.vec;
     
115.     v.insert(v.begin(), 1, 0);
     
116.     size_t s = v.size();
     
117.     for (size_t i = s - 1; i > 0; i--)
     
118.     {
     
119.         int t = v[i];
     
120.         v[i] = t % 10;
     
121.         v[i - 1] += t / 10;
     
122.     }
     
123.     return *this;
     
124. }
     
125. //借1
     
126. void lnum::Borrow(vector<int> &v) const
     
127. {
     
128.     size_t s = v.size();
     
129.     for (size_t i = 1; i < s; i++)
     
130.     {
     
131.         v[i - 1] -= 1;
     
132.         v[i] += 10;
     
133.     }
     
134. }
     
135. //对齐
     
136. const lnum::align lnum::AlignVec(const vector<int> &m, const vector<int> &n) const
     
137. {
     
138.     align agn;
     
139.     vector<int> &fst = agn.first, &sec = agn.second;
     
140.     fst = m, sec = n;
     
141.     size_t fsize = fst.size(), ssize = sec.size();
     
142.     if (fsize < ssize)
     
143.     {
     
144.         fst.insert(fst.begin(), ssize - fsize, 0);
     
145.     }
     
146.     else if (fsize > ssize)
     
147.     {
     
148.         sec.insert(sec.begin(), fsize - ssize, 0);
     
149.     }
     
150.     return agn;
     
151. }
     
152. //反转正负
     
153. const lnum lnum::Negative() const
     
154. {
     
155.     lnum r = *this;
     
156.     r.num.sign = -num.sign;
     
157.     return r;
     
158. }
     
159. //clear zero vec
     
160. lnum &lnum::ClearZeroVec()
     
161. {
     
162.     const size_t &prec = num.prec;
     
163.     vector<int> &v = num.vec;
     
164.     if (v == vector<int>(v.size(), 0))
     
165.     {
     
166.         v.clear();
     
167.         v.push_back(0);
     
168.     }
     
169.     else if (v[0] == 0)
     
170.     {
     
171.         size_t s = v.size(), i = 0;
     
172.         if (prec != 0)
     
173.         {
     
174. 
     
175.             for (; i < s; i++)
     
176.             {
     
177.                 if (v[i] != 0)
     
178.                 {
     
179.                     break;
     
180.                 }
     
181.             }
     
182.             if (i >= s - prec)
     
183.             {
     
184.                 v.erase(v.begin(), v.begin() + (s - prec - 1));
     
185.             }
     
186.             else if (i < s - prec)
     
187.             {
     
188.                 v.erase(v.begin(), v.begin() + i);
     
189.             }
     
190.         }
     
191.         else
     
192.         {
     
193.             for (i = 0; i < s; i++)
     
194.             {
     
195.                 if (v[i] != 0)
     
196.                 {
     
197.                     break;
     
198.                 }
     
199.             }
     
200.             v.erase(v.begin(), v.begin() + i);
     
201.         }
     
202.     }
     
203.     return *this;
     
204. }
     
205. //vec to str
     
206. lnum &lnum::VecToStr()
     
207. {
     
208.     num.str.clear();
     
209.     for (int i : num.vec)
     
210.     {
     
211.         num.str.push_back(i + 48);
     
212.     }
     
213.     return *this;
     
214. }
     
215. //------------------------------------------------------------------------
     
216. //设置精度
     
217. void lnum::SetPrecision(const size_t i)
     
218. {
     
219.     lnum::precision = i;
     
220. }
     
221. //展示信息
     
222. void lnum::Showinfo() const
     
223. {
     
224.     std::cout << "有效数位: ";
     
225.     for (int i : num.vec)
     
226.     {
     
227.         std::cout << i << " ";
     
228.     }
     
229.     std::cout << std::endl;
     
230.     std::cout << "正负符号: " << num.sign << "\n"
     
231.               << "小数位数: " << num.dpsize << "\n"
     
232.               << "小数精度: " << num.prec << "\n"
     
233.               << "有效位数: " << num.nsize << std::endl;
     
234. }
     
235. //>
     
236. const bool lnum::operator>(const lnum &l) const
     
237. {
     
238.     bool f = true;
     
239.     align agn = AlignVec(num.vec, l.num.vec);
     
240.     const vector<int> &fst = agn.first, &sec = agn.second;
     
241.     if (num.sign < l.num.sign)
     
242.     {
     
243.         f = false;
     
244.     }
     
245.     if (num.sign == l.num.sign)
     
246.     {
     
247.         f = fst > sec;
     
248.         if (num.sign == -1)
     
249.         {
     
250.             f = !f;
     
251.         }
     
252.     }
     
253.     return f;
     
254. }
     
255. //<
     
256. const bool lnum::operator<(const lnum &l) const
     
257. {
     
258.     bool f = true;
     
259.     align agn = AlignVec(num.vec, l.num.vec);
     
260.     const vector<int> &fst = agn.first, &sec = agn.second;
     
261.     if (num.sign > l.num.sign)
     
262.     {
     
263.         f = false;
     
264.     }
     
265.     if (num.sign == l.num.sign)
     
266.     {
     
267.         f = fst < sec;
     
268.         if (num.sign == -1)
     
269.         {
     
270.             f = !f;
     
271.         }
     
272.     }
     
273.     return f;
     
274. }
     
275. //==
     
276. const bool lnum::operator==(const lnum &l) const
     
277. {
     
278.     align agn = AlignVec(num.vec, l.num.vec);
     
279.     const vector<int> &fst = agn.first, &sec = agn.second;
     
280.     return fst == sec && num.sign == l.num.sign;
     
281. }
     
282. //>=
     
283. const bool lnum::operator>=(const lnum &l) const
     
284. {
     
285.     return !(*this < l);
     
286. }
     
287. //<=
     
288. const bool lnum::operator<=(const lnum &l) const
     
289. {
     
290.     return !(*this > l);
     
291. }
     
292. //+
     
293. const lnum lnum::operator+(const lnum &l) const
     
294. {
     
295. 
     
296.     lnum r;
     
297.     attr &lr = r.num;
     
298.     const align &agn = AlignVec(num.vec, l.num.vec);
     
299.     const int &tsgn = num.sign, &lsgn = l.num.sign;
     
300.     const vector<int> &fst = agn.first, &sec = agn.second, &tvec = num.vec, &lvec = l.num.vec;
     
301.     lr.prec = num.prec;
     
302.     lr.dpsize = num.dpsize >= l.num.dpsize ? num.dpsize : l.num.dpsize;
     
303.     size_t s = fst.size() <= sec.size() ? fst.size() : sec.size();
     
304.     lr.vec = fst >= sec ? fst : sec;
     
305.     for (size_t i = 0; i < s; i++)
     
306.     {
     
307.         lr.vec[i] += (tsgn * lsgn) * ((sec <= fst ? sec : fst)[i]);
     
308.     }
     
309.     if ((fst > sec && tsgn < lsgn) || (fst < sec && tsgn > lsgn) || (tsgn == -1 && lsgn == -1))
     
310.     {
     
311.         lr.sign = -1;
     
312.     }
     
313.     Borrow(lr.vec);
     
314.     r.Carry().ClearZeroVec().VecToStr();
     
315.     lr.nsize = lr.vec.size();
     
316.     return r;
     
317. }
     
318. //-
     
319. const lnum lnum::operator-(const lnum &l) const
     
320. {
     
321.     lnum r;
     
322.     if (l.num.vec != vector<int>(1,0))
     
323.     {
     
324.         r = *this + l.Negative();
     
325.     }
     
326.     else
     
327.     {
     
328.         r = *this;
     
329.     }
     
330.     return r;
     
331. }
     
332. //>>
     
333. istream &operator>>(istream &is, lnum &l)
     
334. {
     
335.     string str;
     
336.     (is >> str).get();
     
337.     l = str;
     
338.     return is;
     
339. }
     
340. //<<
     
341. ostream &operator<<(ostream &os, const lnum &l)
     
342. {
     
343.     os << l.AttrToStr();
     
344.     return os;
     
345. }
     

复制代码

test.cpp

1. #include "E:\Users\admin\Documents\VScode\Code\My Class\shape.cpp\lnum\lnum.cpp"
   
2. int main(int argc, char const *argv[])
   
3. {
   
4.     lnum::SetPrecision(3);
   
5.     lnum a, b;
   
6.     int i = 0;
   
7.     while (i != 7)
   
8.     {
   
9.         std::cout << "input data:\n";
   
10.         std::cin >> a >> b;
    
11.         std::cout << "a = " << a << "\n"
    
12.                   << "b = " << b << "\n"
    
13.                   << "a + b = " << (a + b) << "\n"
    
14.                   << "a - b = " << (a - b) << std::endl;
    
15.         i++;
    
16.     }
    
17.     return 0;
    
18. }
    

复制代码

======================================================
Microsoft Windows [版本 10.0.18363.535]
(c) 2019 Microsoft Corporation。保留所有权利。

E:\Users\admin\Documents\VScode\Code>c:\Users\admin\.vscode\extensions\ms-vscode.cpptools-0.26.2\debugAdapters\bin\WindowsDebugLauncher.exe --stdin=Microsoft-MIEngine-In-scgixi2r.ntb --stdout=Microsoft-MIEngine-Out-luutv21b.4xa --stderr=Microsoft-MIEngine-Error-pjehcj35.j3v --pid=Microsoft-MIEngine-Pid-bxz2vs3q.lkd --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi
input data:
0
123456789
a = 0
b = 123456789     
a + b = 123456789
a - b = -123456789
input data:      
123456789
0
a = 123456789
b = 0
a + b = 123456789
a - b = 123456789
input data:
-123456789
0
a = -123456789
b = 0
a + b = -123456789
a - b = -123456789
input data:
-123456789
0
a = -123456789
b = 0
a + b = -123456789
a - b = -123456789
input data:
-123456789
123456789
a = -123456789
b = 123456789
a + b = 0
a - b = -246913578
input data:
0
-123456789
a = 0
b = -123456789
a + b = -123456789
a - b = 123456789
input data:
999999999
555555555
a = 999999999
b = 555555555
a + b = 1555555554
a - b = 444444444

E:\Users\admin\Documents\VScode\Code>

bin554385863

加减完成

lnum.h

1. #ifndef LNUM_H
   
2. #define LNUM_H
   
3. #include <iostream>
   
4. #include <string>
   
5. #include <vector>
   
6. using std::istream;
   
7. using std::ostream;
   
8. using std::string;
   
9. using std::vector;
   
10. class lnum
    
11. {
    
12.     struct attr
    
13.     {
    
14.         int sign = 1;          //符号;
    
15.         size_t dpsize = 0;     //小数位;
    
16.         size_t prec = 0;       //精度
    
17.         size_t nsize = 1;      //有效位数
    
18.         string str = "0";      //过渡字符串
    
19.         vector<int> vec = {0}; //数组;
    
20.     };
    
21.     struct align
    
22.     {
    
23.         vector<int> first;
    
24. 
    
25.         vector<int> second;
    
26.     };
    
27. 
    
28. private:
    
29.     //小数精度;
    
30.     static size_t precision;
    
31.     //数据;
    
32.     attr num;
    
33.     //str to attr
    
34.     const attr StrToAttr(const string &str) const;
    
35.     //attr to str
    
36.     const string AttrToStr() const;
    
37.     //进1
    
38.     lnum &Carry();
    
39.     //借1
    
40.     lnum Borrow();
    
41.     //对齐
    
42.     const align AlignVec(const vector<int> &m, const vector<int> &n) const;
    
43.     //反转正负
    
44.     const lnum Negative() const;
    
45.     //clear zero vec
    
46.     lnum &ClearZeroVec();
    
47.     //vec to str
    
48.     lnum &VecToStr();
    
49. 
    
50. public:
    
51.     lnum(const char *cstr = "0") : num(StrToAttr(cstr)){}
    
52.     lnum(const string &str) : num(StrToAttr(str)) {}
    
53.     lnum(const char c) : num(StrToAttr(string(1, c))) {}
    
54.     lnum(const lnum &l) : num(l.num) {}
    
55.     //------------------------------------------------------------------
    
56.     //设置精度
    
57.     static void SetPrecision(const size_t i);
    
58.     //展示信息
    
59.     void Showinfo() const;
    
60.     //>
    
61.     const bool operator>(const lnum &l) const;
    
62.     //<
    
63.     const bool operator<(const lnum &l) const;
    
64.     //==
    
65.     const bool operator==(const lnum &l) const;
    
66.     //>=
    
67.     const bool operator>=(const lnum &l) const;
    
68.     //<=
    
69.     const bool operator<=(const lnum &l) const;
    
70.     //+
    
71.     const lnum operator+(const lnum &l) const;
    
72.     //-
    
73.     const lnum operator-(const lnum &l) const;
    
74.     //>>
    
75.     friend istream &operator>>(istream &is, const lnum &l);
    
76.     //<<
    
77.     friend ostream &operator<<(ostream &os, const lnum &l);
    
78. };
    
79. size_t lnum::precision = 0;
    
80. #endif

复制代码

lnum.cpp

1. #include "E:\Users\admin\Documents\VScode\Code\My Class\shape.cpp\lnum\lnum.h"
   
2. //str to attr
   
3. const lnum::attr lnum::StrToAttr(const string &str) const
   
4. {
   
5.     attr n;
   
6.     n.prec = precision;
   
7.     n.str = str;
   
8.     string &nstr = n.str;
   
9.     size_t &ndps = n.dpsize, &npre = n.prec;
   
10.     if (nstr[0] == '-')
    
11.     {
    
12.         nstr.erase(0, 1);
    
13.     }
    
14.     if (int(nstr.find('.')) != -1)
    
15.     {
    
16.         nstr.erase(nstr.find('.'), 1);
    
17.     }
    
18.     if (nstr == string(nstr.size(), '0'))
    
19.     {
    
20.         nstr.clear();
    
21.         nstr.push_back('0');
    
22.     }
    
23.     else //if (nstr != string(nstr.size(), '0'))
    
24.     {
    
25.         size_t s = nstr.size(), i = 0;
    
26.         if (str[0] == '-')
    
27.         {
    
28.             n.sign = -1;
    
29.         }
    
30.         if (int(str.find('.')) != -1)
    
31.         {
    
32.             ndps = str.size() - str.find('.') - 1;
    
33.             if (nstr[0] == '0')
    
34.             {
    
35. 
    
36.                 for (; i < s; i++)
    
37.                 {
    
38.                     if (nstr[i] != '0')
    
39.                     {
    
40.                         break;
    
41.                     }
    
42.                 }
    
43.                 if (i >= s - ndps)
    
44.                 {
    
45.                     nstr.erase(0, s - ndps - 1);
    
46.                 }
    
47.                 else if (i < s - ndps)
    
48.                 {
    
49.                     nstr.erase(0, i);
    
50.                 }
    
51.             }
    
52.         }
    
53.         else
    
54.         {
    
55.             if (nstr[0] == '0')
    
56.             {
    
57.                 for (i = 0; i < s; i++)
    
58.                 {
    
59.                     if (nstr[i] != '0')
    
60.                     {
    
61.                         break;
    
62.                     }
    
63.                 }
    
64.                 nstr.erase(0, i);
    
65.             }
    
66.         }
    
67.         if (npre > ndps)
    
68.         {
    
69.             nstr.insert(nstr.end(), npre - ndps, '0');
    
70.         }
    
71.         else if (npre < ndps)
    
72.         {
    
73.             nstr.erase(nstr.size() - (ndps - npre));
    
74.             ndps = npre;
    
75.         }
    
76.         n.vec.clear();
    
77.         for (char c : nstr)
    
78.         {
    
79.             n.vec.push_back(c - 48);
    
80.         }
    
81.         n.nsize = nstr.size();
    
82.     }
    
83.     return n;
    
84. }
    
85. //attr to str
    
86. const string lnum::AttrToStr() const
    
87. {
    
88.     string t = num.str, &str = t;
    
89.     const size_t &prec = num.prec, &dpsize = num.dpsize;
    
90.     if (str.size() != 1 && prec != 0)
    
91.     {
    
92.         if (dpsize == prec)
    
93.         {
    
94.             str.insert(str.size() - prec, 1, '.');
    
95.         }
    
96.         else if (dpsize < prec && dpsize != 0)
    
97.         {
    
98.             str.erase(str.size() - (prec - dpsize));
    
99.             str.insert(str.size() - dpsize, 1, '.');
    
100.         }
     
101.         else if (dpsize == 0)
     
102.         {
     
103.             str.erase(str.size() - prec);
     
104.         }
     
105.     }
     
106.     if (num.sign == -1)
     
107.     {
     
108.         str.insert(0, 1, '-');
     
109.     }
     
110.     return str;
     
111. }
     
112. //进1
     
113. lnum &lnum::Carry()
     
114. {
     
115.     vector<int> &v = num.vec;
     
116.     v.insert(v.begin(), 1, 0);
     
117.     size_t s = v.size();
     
118.     for (size_t i = s - 1; i > 0; i--)
     
119.     {
     
120.         int t = v[i];
     
121.         v[i] = t % 10;
     
122.         v[i - 1] += t / 10;
     
123.     }
     
124.     return *this;
     
125. }
     
126. //借1
     
127. lnum lnum::Borrow()
     
128. {
     
129.     vector<int> &v = num.vec;
     
130.     size_t s = v.size();
     
131.     for (size_t i = 1; i < s; i++)
     
132.     {
     
133.         v[i - 1] -= 1;
     
134.         v[i] += 10;
     
135.     }
     
136.     return *this;
     
137. }
     
138. //对齐
     
139. const lnum::align lnum::AlignVec(const vector<int> &m, const vector<int> &n) const
     
140. {
     
141.     align agn;
     
142.     vector<int> &fst = agn.first, &sec = agn.second;
     
143.     fst = m, sec = n;
     
144.     size_t fsize = fst.size(), ssize = sec.size();
     
145.     if (fsize < ssize)
     
146.     {
     
147.         fst.insert(fst.begin(), ssize - fsize, 0);
     
148.     }
     
149.     else if (fsize > ssize)
     
150.     {
     
151.         sec.insert(sec.begin(), fsize - ssize, 0);
     
152.     }
     
153.     return agn;
     
154. }
     
155. //反转正负
     
156. const lnum lnum::Negative() const
     
157. {
     
158.     lnum r = *this;
     
159.     r.num.sign = -num.sign;
     
160.     return r;
     
161. }
     
162. //clear zero vec
     
163. lnum &lnum::ClearZeroVec()
     
164. {
     
165.     const size_t &prec = num.prec;
     
166.     vector<int> &v = num.vec;
     
167.     if (v == vector<int>(v.size(), 0))
     
168.     {
     
169.         v.clear();
     
170.         v.push_back(0);
     
171.     }
     
172.     else if (v[0] == 0)
     
173.     {
     
174.         size_t s = v.size(), i = 0;
     
175.         if (prec != 0)
     
176.         {
     
177. 
     
178.             for (; i < s; i++)
     
179.             {
     
180.                 if (v[i] != 0)
     
181.                 {
     
182.                     break;
     
183.                 }
     
184.             }
     
185.             if (i >= s - prec)
     
186.             {
     
187.                 v.erase(v.begin(), v.begin() + (s - prec - 1));
     
188.             }
     
189.             else if (i < s - prec)
     
190.             {
     
191.                 v.erase(v.begin(), v.begin() + i);
     
192.             }
     
193.         }
     
194.         else
     
195.         {
     
196.             for (i = 0; i < s; i++)
     
197.             {
     
198.                 if (v[i] != 0)
     
199.                 {
     
200.                     break;
     
201.                 }
     
202.             }
     
203.             v.erase(v.begin(), v.begin() + i);
     
204.         }
     
205.     }
     
206.     return *this;
     
207. }
     
208. //vec to str
     
209. lnum &lnum::VecToStr()
     
210. {
     
211.     num.str.clear();
     
212.     for (int i : num.vec)
     
213.     {
     
214.         num.str.push_back(i + 48);
     
215.     }
     
216.     return *this;
     
217. }
     
218. //------------------------------------------------------------------------
     
219. //设置精度
     
220. void lnum::SetPrecision(const size_t i)
     
221. {
     
222.     lnum::precision = i;
     
223. }
     
224. //展示信息
     
225. void lnum::Showinfo() const
     
226. {
     
227.     std::cout << "有效数位: ";
     
228.     for (int i : num.vec)
     
229.     {
     
230.         std::cout << i << " ";
     
231.     }
     
232.     std::cout << std::endl;
     
233.     std::cout << "正负符号: " << num.sign << "\n"
     
234.               << "小数位数: " << num.dpsize << "\n"
     
235.               << "小数精度: " << num.prec << "\n"
     
236.               << "有效位数: " << num.nsize << std::endl;
     
237. }
     
238. //>
     
239. const bool lnum::operator>(const lnum &l) const
     
240. {
     
241.     bool f = true;
     
242.     align agn = AlignVec(num.vec, l.num.vec);
     
243.     const vector<int> &fst = agn.first, &sec = agn.second;
     
244.     if (num.sign < l.num.sign)
     
245.     {
     
246.         f = false;
     
247.     }
     
248.     if (num.sign == l.num.sign)
     
249.     {
     
250.         f = fst > sec;
     
251.         if (num.sign == -1)
     
252.         {
     
253.             f = !f;
     
254.         }
     
255.     }
     
256.     return f;
     
257. }
     
258. //<
     
259. const bool lnum::operator<(const lnum &l) const
     
260. {
     
261.     bool f = true;
     
262.     align agn = AlignVec(num.vec, l.num.vec);
     
263.     const vector<int> &fst = agn.first, &sec = agn.second;
     
264.     if (num.sign > l.num.sign)
     
265.     {
     
266.         f = false;
     
267.     }
     
268.     if (num.sign == l.num.sign)
     
269.     {
     
270.         f = fst < sec;
     
271.         if (num.sign == -1)
     
272.         {
     
273.             f = !f;
     
274.         }
     
275.     }
     
276.     return f;
     
277. }
     
278. //==
     
279. const bool lnum::operator==(const lnum &l) const
     
280. {
     
281.     align agn = AlignVec(num.vec, l.num.vec);
     
282.     const vector<int> &fst = agn.first, &sec = agn.second;
     
283.     return fst == sec && num.sign == l.num.sign;
     
284. }
     
285. //>=
     
286. const bool lnum::operator>=(const lnum &l) const
     
287. {
     
288.     return !(*this < l);
     
289. }
     
290. //<=
     
291. const bool lnum::operator<=(const lnum &l) const
     
292. {
     
293.     return !(*this > l);
     
294. }
     
295. //+
     
296. const lnum lnum::operator+(const lnum &l) const
     
297. {
     
298. 
     
299.     lnum r;
     
300.     attr &lr = r.num;
     
301.     const align &agn = AlignVec(num.vec, l.num.vec);
     
302.     const int &tsgn = num.sign, &lsgn = l.num.sign;
     
303.     const vector<int> &fst = agn.first, &sec = agn.second, &tvec = num.vec, &lvec = l.num.vec;
     
304.     lr.prec = num.prec;
     
305.     lr.dpsize = (num.dpsize >= l.num.dpsize ? num.dpsize : l.num.dpsize);
     
306.     size_t s = (fst.size() <= sec.size() ? fst.size() : sec.size());
     
307.     lr.vec = (fst >= sec ? fst : sec);
     
308.     for (size_t i = 0; i < s; i++)
     
309.     {
     
310.         lr.vec[i] += (tsgn * lsgn) * ((sec <= fst ? sec : fst)[i]);
     
311.     }
     
312.     if ((fst > sec && tsgn < lsgn) || (fst < sec && tsgn > lsgn) || (tsgn == -1 && lsgn == -1))
     
313.     {
     
314.         lr.sign = -1;
     
315.     }
     
316.     if (tsgn*lsgn == -1)
     
317.     {
     
318.         r.Borrow();
     
319.     }
     
320.     r.Carry().ClearZeroVec().VecToStr();
     
321.     lr.nsize = lr.vec.size();
     
322.     return r;
     
323. }
     
324. //-
     
325. const lnum lnum::operator-(const lnum &l) const
     
326. {
     
327.     lnum r;
     
328.     if (l.num.vec != vector<int>(1,0))
     
329.     {
     
330.         r = *this + l.Negative();
     
331.     }
     
332.     else
     
333.     {
     
334.         r = *this;
     
335.     }
     
336.     return r;
     
337. }
     
338. //>>
     
339. istream &operator>>(istream &is, lnum &l)
     
340. {
     
341.     string str;
     
342.     (is >> str).get();
     
343.     l = str;
     
344.     return is;
     
345. }
     
346. //<<
     
347. ostream &operator<<(ostream &os, const lnum &l)
     
348. {
     
349.     os << l.AttrToStr();
     
350.     return os;
     
351. }
     

复制代码

test.cpp

1. #include "E:\Users\admin\Documents\VScode\Code\My Class\shape.cpp\lnum\lnum.cpp"
   
2. #include <ctime>
   
3. int main(int argc, char const *argv[])
   
4. {
   
5.     //lnum::SetPrecision();
   
6.     lnum a, b;
   
7.     int s = 0;
   
8.     char m[5], n[5];
   
9.     m[4] = '\0';
   
10.     n[4] = '\0';
    
11.     srand(time(NULL));
    
12.     while (s != 10)
    
13.     {
    
14.         for (size_t i = 0; i < 4; i++)
    
15.         {
    
16.             m[i] = 48+(rand() % 9);
    
17.             n[i] = 48 + (rand() % 9);
    
18.         }
    
19.         a = m;
    
20.         b = n;
    
21.         std::cout << "a = " << a << "\n"
    
22.                   << "b = " << b << "\n"
    
23.                   << "a + b = " << (a + b) << "\n"
    
24.                   << "a - b = " << (a - b) << std::boolalpha << "\n"
    
25.                   << "a >  b: " << (a > b) << "\n"
    
26.                   << "a == b: " << (a == b) << "\n"
    
27.                   << "a <  b: " << (a < b)<<std::endl;
    
28.         s++;
    
29.     }
    
30.     return 0;
    
31. }
    

复制代码

===================================================
Microsoft Windows [版本 10.0.18363.535]
(c) 2019 Microsoft Corporation。保留所有权利。

E:\Users\admin\Documents\VScode\Code>c:\Users\admin\.vscode\extensions\ms-vscode.cpptools-0.26.2\debugAdapters\bin\WindowsDebugLauncher.exe --stdin=Microsoft-MIEngine-In-eboo5i2a.scs --stdout=Microsoft-MIEngine-Out-r4tarar5.3rq --stderr=Microsoft-MIEngine-Error-qhegr14x.fpe --pid=Microsoft-MIEngine-Pid-fmhxlme1.czb --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi
a = 5332     
b = 401      
a + b = 5733
a - b = 4931
a >  b: true
a == b: false
a <  b: false
a = 58      
b = 664      
a + b = 722  
a - b = -606
a >  b: false
a == b: false
a <  b: true
a = 4535
b = 4804
a + b = 9339
a - b = -269
a >  b: false
a == b: false
a <  b: true
a = 3751
b = 580
a + b = 4331
a - b = 3171
a >  b: true
a == b: false
a <  b: false
a = 1725
b = 8817
a + b = 10542
a - b = -7092
a >  b: false
a == b: false
a <  b: true
a = 6707
b = 2004
a + b = 8711
a - b = 4703
a >  b: true
a == b: false
a <  b: false
a = 1604
b = 626
a + b = 2230
a - b = 978
a >  b: true
a == b: false
a <  b: false
a = 6284
b = 4865
a + b = 11149
a - b = 1419
a >  b: true
a == b: false
a <  b: false
a = 1810
b = 3604
a + b = 5414
a - b = -1794
a >  b: false
a == b: false
a <  b: true
a = 4671
b = 8577
a + b = 13248
a - b = -3906
a >  b: false
a == b: false
a <  b: true

E:\Users\admin\Documents\VScode\Code>

bin554385863

1. num.h
   
2. 
   
3. #ifndef LNUM_H
   
4. #define LNUM_H
   
5. #include <iostream>
   
6. #include <string>
   
7. #include <vector>
   
8. using std::istream;
   
9. using std::ostream;
   
10. using std::string;
    
11. using std::vector;
    
12. class lnum
    
13. {
    
14.     struct attr
    
15.     {
    
16.         int sign = 1;          //符号;
    
17.         size_t dpsize = 0;     //小数位;
    
18.         size_t prec = 0;       //精度
    
19.         size_t nsize = 1;      //有效位数
    
20.         string str = "0";      //过渡字符串
    
21.         vector<int> vec = {0}; //数组;
    
22.     };
    
23.     struct align
    
24.     {
    
25.         vector<int> first;
    
26.         vector<int> second;
    
27.     };
    
28. 
    
29. private:
    
30.     //小数精度;
    
31.     static size_t precision;
    
32.     //数据;
    
33.     attr num;
    
34.     //str to attr
    
35.     const attr StrToAttr(const string &str) const;
    
36.     //attr to str
    
37.     const string AttrToStr() const;
    
38.     //进1
    
39.     lnum &Carry();
    
40.     //借1
    
41.     lnum Borrow();
    
42.     //对齐
    
43.     const align AlignVec(const vector<int> &m, const vector<int> &n) const;
    
44.     //clear zero vec
    
45.     lnum &ClearZeroVec();
    
46.     //vec to str
    
47.     lnum &VecToStr();
    
48. 
    
49. public:
    
50.     lnum(const char *cstr = "0") : num(StrToAttr(cstr)){}
    
51.     lnum(const string &str) : num(StrToAttr(str)) {}
    
52.     lnum(const char c) : num(StrToAttr(string(1, c))) {}
    
53.     lnum(const lnum &l) : num(l.num) {}
    
54.     //------------------------------------------------------------------
    
55.     //设置精度
    
56.     static void SetPrecision(const size_t i);
    
57.     //展示信息
    
58.     void Showinfo() const;
    
59.     //>
    
60.     const bool operator>(const lnum &l) const;
    
61.     //<
    
62.     const bool operator<(const lnum &l) const;
    
63.     //==
    
64.     const bool operator==(const lnum &l) const;
    
65.     //>=
    
66.     const bool operator>=(const lnum &l) const;
    
67.     //<=
    
68.     const bool operator<=(const lnum &l) const;
    
69.     //+
    
70.     const lnum operator+(const lnum &l) const;
    
71.     //-
    
72.     const lnum operator-(const lnum &l) const;
    
73.     const lnum operator-() const;
    
74.     //>>
    
75.     friend istream &operator>>(istream &is, const lnum &l);
    
76.     //<<
    
77.     friend ostream &operator<<(ostream &os, const lnum &l);
    
78. };
    
79. size_t lnum::precision = 0;
    
80. #endif
    
81. 
    
82. lnum.cpp
    
83. 
    
84. #include "E:\Users\admin\Documents\VScode\Code\My Class\shape.cpp\lnum\lnum.h"
    
85. //str to attr
    
86. const lnum::attr lnum::StrToAttr(const string &str) const
    
87. {
    
88.     attr n;
    
89.     n.prec = precision;
    
90.     n.str = str;
    
91.     string &nstr = n.str;
    
92.     size_t &ndps = n.dpsize, &npre = n.prec;
    
93.     if (nstr[0] == '-')
    
94.     {
    
95.         nstr.erase(0, 1);
    
96.     }
    
97.     if (int(nstr.find('.')) != -1)
    
98.     {
    
99.         nstr.erase(nstr.find('.'), 1);
    
100.     }
     
101.     if (nstr == string(nstr.size(), '0'))
     
102.     {
     
103.         nstr.clear();
     
104.         nstr.push_back('0');
     
105.     }
     
106.     else //if (nstr != string(nstr.size(), '0'))
     
107.     {
     
108.         size_t s = nstr.size(), i = 0;
     
109.         if (str[0] == '-')
     
110.         {
     
111.             n.sign = -1;
     
112.         }
     
113.         if (int(str.find('.')) != -1)
     
114.         {
     
115.             ndps = str.size() - str.find('.') - 1;
     
116.             if (nstr[0] == '0')
     
117.             {
     
118. 
     
119.                 for (; i < s; i++)
     
120.                 {
     
121.                     if (nstr[i] != '0')
     
122.                     {
     
123.                         break;
     
124.                     }
     
125.                 }
     
126.                 if (i >= s - ndps)
     
127.                 {
     
128.                     nstr.erase(0, s - ndps - 1);
     
129.                 }
     
130.                 else if (i < s - ndps)
     
131.                 {
     
132.                     nstr.erase(0, i);
     
133.                 }
     
134.             }
     
135.         }
     
136.         else
     
137.         {
     
138.             if (nstr[0] == '0')
     
139.             {
     
140.                 for (i = 0; i < s; i++)
     
141.                 {
     
142.                     if (nstr[i] != '0')
     
143.                     {
     
144.                         break;
     
145.                     }
     
146.                 }
     
147.                 nstr.erase(0, i);
     
148.             }
     
149.         }
     
150.         if (npre > ndps)
     
151.         {
     
152.             nstr.insert(nstr.end(), npre - ndps, '0');
     
153.         }
     
154.         else if (npre < ndps)
     
155.         {
     
156.             nstr.erase(nstr.size() - (ndps - npre));
     
157.             ndps = npre;
     
158.         }
     
159.         n.vec.clear();
     
160.         for (char c : nstr)
     
161.         {
     
162.             n.vec.push_back(c - 48);
     
163.         }
     
164.         n.nsize = nstr.size();
     
165.     }
     
166.     return n;
     
167. }
     
168. //attr to str
     
169. const string lnum::AttrToStr() const
     
170. {
     
171.     string t = num.str, &str = t;
     
172.     const size_t &prec = num.prec, &dpsize = num.dpsize;
     
173.     if (str.size() != 1 && prec != 0)
     
174.     {
     
175.         if (dpsize == prec)
     
176.         {
     
177.             str.insert(str.size() - prec, 1, '.');
     
178.         }
     
179.         else if (dpsize < prec && dpsize != 0)
     
180.         {
     
181.             str.erase(str.size() - (prec - dpsize));
     
182.             str.insert(str.size() - dpsize, 1, '.');
     
183.         }
     
184.         else if (dpsize == 0)
     
185.         {
     
186.             str.erase(str.size() - prec);
     
187.         }
     
188.     }
     
189.     if (num.sign == -1)
     
190.     {
     
191.         str.insert(0, 1, '-');
     
192.     }
     
193.     return str;
     
194. }
     
195. //进1
     
196. lnum &lnum::Carry()
     
197. {
     
198.     vector<int> &v = num.vec;
     
199.     v.insert(v.begin(), 1, 0);
     
200.     size_t s = v.size();
     
201.     for (size_t i = s - 1; i > 0; i--)
     
202.     {
     
203.         int t = v[i];
     
204.         v[i] = t % 10;
     
205.         v[i - 1] += t / 10;
     
206.     }
     
207.     return *this;
     
208. }
     
209. //借1
     
210. lnum lnum::Borrow()
     
211. {
     
212.     vector<int> &v = num.vec;
     
213.     size_t s = v.size();
     
214.     for (size_t i = 1; i < s; i++)
     
215.     {
     
216.         v[i - 1] -= 1;
     
217.         v[i] += 10;
     
218.     }
     
219.     return *this;
     
220. }
     
221. //对齐
     
222. const lnum::align lnum::AlignVec(const vector<int> &m, const vector<int> &n) const
     
223. {
     
224.     align agn;
     
225.     vector<int> &fst = agn.first, &sec = agn.second;
     
226.     fst = m, sec = n;
     
227.     size_t fsize = fst.size(), ssize = sec.size();
     
228.     if (fsize < ssize)
     
229.     {
     
230.         fst.insert(fst.begin(), ssize - fsize, 0);
     
231.     }
     
232.     else if (fsize > ssize)
     
233.     {
     
234.         sec.insert(sec.begin(), fsize - ssize, 0);
     
235.     }
     
236.     return agn;
     
237. }
     
238. //clear zero vec
     
239. lnum &lnum::ClearZeroVec()
     
240. {
     
241.     const size_t &prec = num.prec;
     
242.     vector<int> &v = num.vec;
     
243.     if (v == vector<int>(v.size(), 0))
     
244.     {
     
245.         v.clear();
     
246.         v.push_back(0);
     
247.     }
     
248.     else if (v[0] == 0)
     
249.     {
     
250.         size_t s = v.size(), i = 0;
     
251.         if (prec != 0)
     
252.         {
     
253. 
     
254.             for (; i < s; i++)
     
255.             {
     
256.                 if (v[i] != 0)
     
257.                 {
     
258.                     break;
     
259.                 }
     
260.             }
     
261.             if (i >= s - prec)
     
262.             {
     
263.                 v.erase(v.begin(), v.begin() + (s - prec - 1));
     
264.             }
     
265.             else if (i < s - prec)
     
266.             {
     
267.                 v.erase(v.begin(), v.begin() + i);
     
268.             }
     
269.         }
     
270.         else
     
271.         {
     
272.             for (i = 0; i < s; i++)
     
273.             {
     
274.                 if (v[i] != 0)
     
275.                 {
     
276.                     break;
     
277.                 }
     
278.             }
     
279.             v.erase(v.begin(), v.begin() + i);
     
280.         }
     
281.     }
     
282.     return *this;
     
283. }
     
284. //vec to str
     
285. lnum &lnum::VecToStr()
     
286. {
     
287.     num.str.clear();
     
288.     for (int i : num.vec)
     
289.     {
     
290.         num.str.push_back(i + 48);
     
291.     }
     
292.     return *this;
     
293. }
     
294. //------------------------------------------------------------------------
     
295. //设置精度
     
296. void lnum::SetPrecision(const size_t i)
     
297. {
     
298.     lnum::precision = i;
     
299. }
     
300. //展示信息
     
301. void lnum::Showinfo() const
     
302. {
     
303.     std::cout << "有效数位: ";
     
304.     for (int i : num.vec)
     
305.     {
     
306.         std::cout << i << " ";
     
307.     }
     
308.     std::cout << std::endl;
     
309.     std::cout << "正负符号: " << num.sign << "\n"
     
310.               << "小数位数: " << num.dpsize << "\n"
     
311.               << "小数精度: " << num.prec << "\n"
     
312.               << "有效位数: " << num.nsize << std::endl;
     
313. }
     
314. //>
     
315. const bool lnum::operator>(const lnum &l) const
     
316. {
     
317.     bool f = true;
     
318.     align agn = AlignVec(num.vec, l.num.vec);
     
319.     const vector<int> &fst = agn.first, &sec = agn.second;
     
320.     if (num.sign < l.num.sign)
     
321.     {
     
322.         f = false;
     
323.     }
     
324.     if (num.sign == l.num.sign)
     
325.     {
     
326.         f = fst > sec;
     
327.         if (num.sign == -1)
     
328.         {
     
329.             f = !f;
     
330.         }
     
331.     }
     
332.     return f;
     
333. }
     
334. //<
     
335. const bool lnum::operator<(const lnum &l) const
     
336. {
     
337.     bool f = true;
     
338.     align agn = AlignVec(num.vec, l.num.vec);
     
339.     const vector<int> &fst = agn.first, &sec = agn.second;
     
340.     if (num.sign > l.num.sign)
     
341.     {
     
342.         f = false;
     
343.     }
     
344.     if (num.sign == l.num.sign)
     
345.     {
     
346.         f = fst < sec;
     
347.         if (num.sign == -1)
     
348.         {
     
349.             f = !f;
     
350.         }
     
351.     }
     
352.     return f;
     
353. }
     
354. //==
     
355. const bool lnum::operator==(const lnum &l) const
     
356. {
     
357.     align agn = AlignVec(num.vec, l.num.vec);
     
358.     const vector<int> &fst = agn.first, &sec = agn.second;
     
359.     return fst == sec && num.sign == l.num.sign;
     
360. }
     
361. //>=
     
362. const bool lnum::operator>=(const lnum &l) const
     
363. {
     
364.     return !(*this < l);
     
365. }
     
366. //<=
     
367. const bool lnum::operator<=(const lnum &l) const
     
368. {
     
369.     return !(*this > l);
     
370. }
     
371. //+
     
372. const lnum lnum::operator+(const lnum &l) const
     
373. {
     
374. 
     
375.     lnum r;
     
376.     attr &lr = r.num;
     
377.     const align &agn = AlignVec(num.vec, l.num.vec);
     
378.     const int &tsgn = num.sign, &lsgn = l.num.sign;
     
379.     const vector<int> &fst = agn.first, &sec = agn.second, &tvec = num.vec, &lvec = l.num.vec;
     
380.     lr.prec = num.prec;
     
381.     lr.dpsize = (num.dpsize >= l.num.dpsize ? num.dpsize : l.num.dpsize);
     
382.     size_t s = (fst.size() <= sec.size() ? fst.size() : sec.size());
     
383.     lr.vec = (fst >= sec ? fst : sec);
     
384.     for (size_t i = 0; i < s; i++)
     
385.     {
     
386.         lr.vec[i] += (tsgn * lsgn) * ((sec <= fst ? sec : fst)[i]);
     
387.     }
     
388.     if ((fst > sec && tsgn < lsgn) || (fst < sec && tsgn > lsgn) || (tsgn == -1 && lsgn == -1))
     
389.     {
     
390.         lr.sign = -1;
     
391.     }
     
392.     if (tsgn*lsgn == -1)
     
393.     {
     
394.         r.Borrow();
     
395.     }
     
396.     r.Carry().ClearZeroVec().VecToStr();
     
397.     lr.nsize = lr.vec.size();
     
398.     return r;
     
399. }
     
400. //符号取反
     
401. const lnum lnum::operator-() const
     
402. {
     
403.     const vector<int> &tvec = num.vec;
     
404.     lnum r = *this;
     
405.     if (tvec != vector<int>(tvec.size(), 0))
     
406.     {
     
407.         r.num.sign = -num.sign;
     
408.     }
     
409.     return r;
     
410. }
     
411. //-
     
412. const lnum lnum::operator-(const lnum &l) const
     
413. {
     
414.     lnum r;
     
415.     if (l.num.vec != vector<int>(1,0))
     
416.     {
     
417.         r = *this + (-l);
     
418.     }
     
419.     else
     
420.     {
     
421.         r = *this;
     
422.     }
     
423.     return r;
     
424. }
     
425. //>>
     
426. istream &operator>>(istream &is, lnum &l)
     
427. {
     
428.     string str;
     
429.     (is >> str).get();
     
430.     l = str;
     
431.     return is;
     
432. }
     
433. //<<
     
434. ostream &operator<<(ostream &os, const lnum &l)
     
435. {
     
436.     os << l.AttrToStr();
     
437.     return os;
     
438. }
     
439. 
     
440. 
     
441. test.cpp
     
442. 
     
443. #include "E:\Users\admin\Documents\VScode\Code\My Class\shape.cpp\lnum\lnum.cpp"
     
444. #include <ctime>
     
445. #include <cmath>
     
446. int main(int argc, char const *argv[])
     
447. {
     
448.     //lnum::SetPrecision();
     
449.     lnum a, b;
     
450.     int s = 0;
     
451.     char m[5], n[5];
     
452.     m[4] = '\0';
     
453.     n[4] = '\0';
     
454.     srand(time(NULL));
     
455.     while (s != 10)
     
456.     {
     
457.         for (size_t i = 0; i < 4; i++)
     
458.         {
     
459.             m[i] = (48+(rand() % 9));
     
460.             n[i] = 48 + (rand() % 9);
     
461.             if (m[i] % 3 == 0)
     
462.             {
     
463.                 m[0] = '-';
     
464.             }
     
465.             if (n[2] % 2== 0)
     
466.             {
     
467.                 n[0] = '-';
     
468.             }
     
469.         }
     
470.         a = m;
     
471.         b = n;
     
472.         std::cout << "a = " << a << "  "
     
473.                   << "b = " << b << "\n"
     
474.                   << a << " +  " << b << " = " << (a + b) << "\n"
     
475.                   << a << " -  " << b << " = " << (a - b) << std::boolalpha << "\n"
     
476.                   << a << " >  " << b << " : " << (a > b) << "\n"
     
477.                   << a << " == " << b << " : " << (a == b) << "\n"
     
478.                   << a << " <  " << b << " : " << (a < b) << "\n"
     
479.                   << std::endl;
     
480.         s++;
     
481.     }
     
482.     return 0;
     
483. }
     

复制代码

========================================================
Microsoft Windows [版本 10.0.18363.535]
(c) 2019 Microsoft Corporation。保留所有权利。

E:\Users\admin\Documents\VScode\Code>c:\Users\admin\.vscode\extensions\ms-vscode.cpptools-0.26.2\debugAdapters\bin\WindowsDebugLauncher.exe --stdin=Microsoft-MIEngine-In-ul1mqoep.0q0 --stdout=Microsoft-MIEngine-Out-unmtncle.kyu --stderr=Microsoft-MIEngine-Error-5vrplf5c.qy3 --pid=Microsoft-MIEngine-Pid-ofqfqron.oyu --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi
a = -862  b = -133
-862 +  -133 = -995
-862 -  -133 = -729
-862 >  -133 : false
-862 == -133 : false
-862 <  -133 : true

a = -317  b = 4114  
-317 +  4114 = 3797
-317 -  4114 = -4431
-317 >  4114 : false
-317 == 4114 : false
-317 <  4114 : true

a = -766  b = 4011
-766 +  4011 = 3245
-766 -  4011 = -4777
-766 >  4011 : false
-766 == 4011 : false
-766 <  4011 : true

a = -533  b = -286
-533 +  -286 = -819
-533 -  -286 = -247
-533 >  -286 : false
-533 == -286 : false
-533 <  -286 : true

a = -28  b = -830
-28 +  -830 = -858
-28 -  -830 = 802
-28 >  -830 : true
-28 == -830 : false
-28 <  -830 : false

a = 7858  b = 2216
7858 +  2216 = 10074
7858 -  2216 = 5642
7858 >  2216 : true
7858 == 2216 : false
7858 <  2216 : false

a = -722  b = -20
-722 +  -20 = -742
-722 -  -20 = -702
-722 >  -20 : false
-722 == -20 : false
-722 <  -20 : true

a = -670  b = -360
-670 +  -360 = -1030
-670 -  -360 = -310
-670 >  -360 : false
-670 == -360 : false
-670 <  -360 : true

a = -231  b = -226
-231 +  -226 = -457
-231 -  -226 = -5
-231 >  -226 : false
-231 == -226 : false
-231 <  -226 : true

a = -782  b = -116
-782 +  -116 = -898
-782 -  -116 = -666
-782 >  -116 : false
-782 == -116 : false
-782 <  -116 : true


E:\Users\admin\Documents\VScode\Code>

bin554385863

lnum.h

1. #ifndef LNUM_H
   
2. #define LNUM_H
   
3. #include <iostream>
   
4. #include <string>
   
5. #include <vector>
   
6. using std::istream;
   
7. using std::ostream;
   
8. using std::string;
   
9. using std::vector;
   
10. class lnum
    
11. {
    
12.     struct attr
    
13.     {
    
14.         int sign = 1;          //符号;
    
15.         size_t dpsize = 0;     //小数位;
    
16.         size_t prec = 0;       //精度
    
17.         size_t nsize = 1;      //有效位数
    
18.         string str = "0";      //过渡字符串
    
19.         vector<int> vec = {0}; //数组;
    
20.     };
    
21.     struct align
    
22.     {
    
23.         vector<int> first;
    
24.         vector<int> second;
    
25.     };
    
26. 
    
27. private:
    
28.     //小数精度;
    
29.     static size_t precision;
    
30.     //数据;
    
31.     attr num;
    
32.     //str to attr
    
33.     const attr StrToAttr(const string &str) const;
    
34.     //attr to str
    
35.     const string AttrToStr() const;
    
36.     //进1
    
37.     lnum &Carry();
    
38.     //借1
    
39.     lnum Borrow();
    
40.     //对齐
    
41.     const align AlignVec(const vector<int> &m, const vector<int> &n) const;
    
42.     //clear zero vec
    
43.     lnum &ClearZeroVec();
    
44.     //vec to str
    
45.     lnum &VecToStr();
    
46.    
    
47. public:
    
48.     lnum(const char *cstr = "0") : num(StrToAttr(cstr)){}
    
49.     lnum(const string &str) : num(StrToAttr(str)){}
    
50.     lnum(const lnum &l) : num(l.num) {}
    
51.     //------------------------------------------------------------------
    
52.     //设置精度
    
53.     static void SetPrecision(const size_t i);
    
54.     //展示信息
    
55.     void Showinfo() const;
    
56.     //>
    
57.     const bool operator>(const lnum &l) const;
    
58.     //<
    
59.     const bool operator<(const lnum &l) const;
    
60.     //==
    
61.     const bool operator==(const lnum &l) const;
    
62.     //>=
    
63.     const bool operator>=(const lnum &l) const;
    
64.     //<=
    
65.     const bool operator<=(const lnum &l) const;
    
66.     //+
    
67.     const lnum operator+(const lnum &l) const;
    
68.     //-
    
69.     const lnum operator-(const lnum &l) const;
    
70.     const lnum operator-() const;
    
71.     //+=
    
72.     const lnum &operator+=(const lnum &l);
    
73.     //++
    
74.     const lnum &operator++();
    
75.     //-=
    
76.     const lnum &operator-=(const lnum &l);
    
77.     //--
    
78.     const lnum &operator--();
    
79.     //odject++
    
80.     friend const lnum &operator++(lnum &l, const int i);
    
81.     //object--
    
82.     friend const lnum &operator--(lnum &l, const int i);
    
83.     //>>
    
84.     friend istream &operator>>(istream &is, const lnum &l);
    
85.     //<<
    
86.     friend ostream &operator<<(ostream &os, const lnum &l);
    
87. };
    
88. size_t lnum::precision = 0;
    
89. #endif

复制代码

lnum.cpp

1. #include "E:\Users\admin\Documents\VScode\Code\My Class\shape.cpp\lnum\lnum.h"
   
2. //str to attr
   
3. const lnum::attr lnum::StrToAttr(const string &str) const
   
4. {
   
5.     attr n;
   
6.     n.prec = precision;
   
7.     n.str = str;
   
8.     string &nstr = n.str;
   
9.     size_t &ndps = n.dpsize, &npre = n.prec;
   
10.     if (nstr[0] == '-')
    
11.     {
    
12.         nstr.erase(0, 1);
    
13.     }
    
14.     if (int(nstr.find('.')) != -1)
    
15.     {
    
16.         nstr.erase(nstr.find('.'), 1);
    
17.     }
    
18.     if (nstr == string(nstr.size(), '0'))
    
19.     {
    
20.         nstr.clear();
    
21.         nstr.push_back('0');
    
22.     }
    
23.     else //if (nstr != string(nstr.size(), '0'))
    
24.     {
    
25.         size_t s = nstr.size(), i = 0;
    
26.         if (str[0] == '-')
    
27.         {
    
28.             n.sign = -1;
    
29.         }
    
30.         if (int(str.find('.')) != -1)
    
31.         {
    
32.             ndps = str.size() - str.find('.') - 1;
    
33.             if (nstr[0] == '0')
    
34.             {
    
35. 
    
36.                 for (; i < s; i++)
    
37.                 {
    
38.                     if (nstr[i] != '0')
    
39.                     {
    
40.                         break;
    
41.                     }
    
42.                 }
    
43.                 if (i >= s - ndps)
    
44.                 {
    
45.                     nstr.erase(0, s - ndps - 1);
    
46.                 }
    
47.                 else if (i < s - ndps)
    
48.                 {
    
49.                     nstr.erase(0, i);
    
50.                 }
    
51.             }
    
52.         }
    
53.         else
    
54.         {
    
55.             if (nstr[0] == '0')
    
56.             {
    
57.                 for (i = 0; i < s; i++)
    
58.                 {
    
59.                     if (nstr[i] != '0')
    
60.                     {
    
61.                         break;
    
62.                     }
    
63.                 }
    
64.                 nstr.erase(0, i);
    
65.             }
    
66.         }
    
67.         if (npre > ndps)
    
68.         {
    
69.             nstr.insert(nstr.end(), npre - ndps, '0');
    
70.         }
    
71.         else if (npre < ndps)
    
72.         {
    
73.             nstr.erase(nstr.size() - (ndps - npre));
    
74.             ndps = npre;
    
75.         }
    
76.         n.vec.clear();
    
77.         for (char c : nstr)
    
78.         {
    
79.             n.vec.push_back(c - 48);
    
80.         }
    
81.         n.nsize = nstr.size();
    
82.     }
    
83.     return n;
    
84. }
    
85. //attr to str
    
86. const string lnum::AttrToStr() const
    
87. {
    
88.     string t = num.str, &str = t;
    
89.     const size_t &prec = num.prec, &dpsize = num.dpsize;
    
90.     if (str.size() != 1 && prec != 0)
    
91.     {
    
92.         if (dpsize == prec)
    
93.         {
    
94.             str.insert(str.size() - prec, 1, '.');
    
95.         }
    
96.         else if (dpsize < prec && dpsize != 0)
    
97.         {
    
98.             str.erase(str.size() - (prec - dpsize));
    
99.             str.insert(str.size() - dpsize, 1, '.');
    
100.         }
     
101.         else if (dpsize == 0)
     
102.         {
     
103.             str.erase(str.size() - prec);
     
104.         }
     
105.     }
     
106.     if (num.sign == -1)
     
107.     {
     
108.         str.insert(0, 1, '-');
     
109.     }
     
110.     return str;
     
111. }
     
112. //进1
     
113. lnum &lnum::Carry()
     
114. {
     
115.     vector<int> &v = num.vec;
     
116.     v.insert(v.begin(), 1, 0);
     
117.     size_t s = v.size();
     
118.     for (size_t i = s - 1; i > 0; i--)
     
119.     {
     
120.         int t = v[i];
     
121.         v[i] = t % 10;
     
122.         v[i - 1] += t / 10;
     
123.     }
     
124.     return *this;
     
125. }
     
126. //借1
     
127. lnum lnum::Borrow()
     
128. {
     
129.     vector<int> &v = num.vec;
     
130.     size_t s = v.size();
     
131.     for (size_t i = 1; i < s; i++)
     
132.     {
     
133.         v[i - 1] -= 1;
     
134.         v[i] += 10;
     
135.     }
     
136.     return *this;
     
137. }
     
138. //对齐
     
139. const lnum::align lnum::AlignVec(const vector<int> &m, const vector<int> &n) const
     
140. {
     
141.     align agn;
     
142.     vector<int> &fst = agn.first, &sec = agn.second;
     
143.     fst = m, sec = n;
     
144.     size_t fsize = fst.size(), ssize = sec.size();
     
145.     if (fsize < ssize)
     
146.     {
     
147.         fst.insert(fst.begin(), ssize - fsize, 0);
     
148.     }
     
149.     else if (fsize > ssize)
     
150.     {
     
151.         sec.insert(sec.begin(), fsize - ssize, 0);
     
152.     }
     
153.     return agn;
     
154. }
     
155. //clear zero vec
     
156. lnum &lnum::ClearZeroVec()
     
157. {
     
158.     const size_t &prec = num.prec;
     
159.     vector<int> &v = num.vec;
     
160.     if (v == vector<int>(v.size(), 0))
     
161.     {
     
162.         v.clear();
     
163.         v.push_back(0);
     
164.     }
     
165.     else if (v[0] == 0)
     
166.     {
     
167.         size_t s = v.size(), i = 0;
     
168.         if (prec != 0)
     
169.         {
     
170. 
     
171.             for (; i < s; i++)
     
172.             {
     
173.                 if (v[i] != 0)
     
174.                 {
     
175.                     break;
     
176.                 }
     
177.             }
     
178.             if (i >= s - prec)
     
179.             {
     
180.                 v.erase(v.begin(), v.begin() + (s - prec - 1));
     
181.             }
     
182.             else if (i < s - prec)
     
183.             {
     
184.                 v.erase(v.begin(), v.begin() + i);
     
185.             }
     
186.         }
     
187.         else
     
188.         {
     
189.             for (i = 0; i < s; i++)
     
190.             {
     
191.                 if (v[i] != 0)
     
192.                 {
     
193.                     break;
     
194.                 }
     
195.             }
     
196.             v.erase(v.begin(), v.begin() + i);
     
197.         }
     
198.     }
     
199.     return *this;
     
200. }
     
201. //vec to str
     
202. lnum &lnum::VecToStr()
     
203. {
     
204.     num.str.clear();
     
205.     for (int i : num.vec)
     
206.     {
     
207.         num.str.push_back(i + 48);
     
208.     }
     
209.     return *this;
     
210. }
     
211. //------------------------------------------------------------------------
     
212. //设置精度
     
213. void lnum::SetPrecision(const size_t i)
     
214. {
     
215.     lnum::precision = i;
     
216. }
     
217. //展示信息
     
218. void lnum::Showinfo() const
     
219. {
     
220.     std::cout << "有效数位: ";
     
221.     for (int i : num.vec)
     
222.     {
     
223.         std::cout << i << " ";
     
224.     }
     
225.     std::cout << std::endl;
     
226.     std::cout << "正负符号: " << num.sign << "\n"
     
227.               << "小数位数: " << num.dpsize << "\n"
     
228.               << "小数精度: " << num.prec << "\n"
     
229.               << "有效位数: " << num.nsize << std::endl;
     
230. }
     
231. //>
     
232. const bool lnum::operator>(const lnum &l) const
     
233. {
     
234.     bool f = true;
     
235.     align agn = AlignVec(num.vec, l.num.vec);
     
236.     const vector<int> &fst = agn.first, &sec = agn.second;
     
237.     if (num.sign < l.num.sign)
     
238.     {
     
239.         f = false;
     
240.     }
     
241.     if (num.sign == l.num.sign)
     
242.     {
     
243.         f = fst > sec;
     
244.         if (num.sign == -1)
     
245.         {
     
246.             f = !f;
     
247.         }
     
248.     }
     
249.     return f;
     
250. }
     
251. //<
     
252. const bool lnum::operator<(const lnum &l) const
     
253. {
     
254.     bool f = true;
     
255.     align agn = AlignVec(num.vec, l.num.vec);
     
256.     const vector<int> &fst = agn.first, &sec = agn.second;
     
257.     if (num.sign > l.num.sign)
     
258.     {
     
259.         f = false;
     
260.     }
     
261.     if (num.sign == l.num.sign)
     
262.     {
     
263.         f = fst < sec;
     
264.         if (num.sign == -1)
     
265.         {
     
266.             f = !f;
     
267.         }
     
268.     }
     
269.     return f;
     
270. }
     
271. //==
     
272. const bool lnum::operator==(const lnum &l) const
     
273. {
     
274.     align agn = AlignVec(num.vec, l.num.vec);
     
275.     const vector<int> &fst = agn.first, &sec = agn.second;
     
276.     return fst == sec && num.sign == l.num.sign;
     
277. }
     
278. //>=
     
279. const bool lnum::operator>=(const lnum &l) const
     
280. {
     
281.     return !(*this < l);
     
282. }
     
283. //<=
     
284. const bool lnum::operator<=(const lnum &l) const
     
285. {
     
286.     return !(*this > l);
     
287. }
     
288. //+
     
289. const lnum lnum::operator+(const lnum &l) const
     
290. {
     
291. 
     
292.     lnum r;
     
293.     attr &lr = r.num;
     
294.     const align &agn = AlignVec(num.vec, l.num.vec);
     
295.     const int &tsgn = num.sign, &lsgn = l.num.sign;
     
296.     const vector<int> &fst = agn.first, &sec = agn.second, &tvec = num.vec, &lvec = l.num.vec;
     
297.     lr.prec = num.prec;
     
298.     lr.dpsize = (num.dpsize >= l.num.dpsize ? num.dpsize : l.num.dpsize);
     
299.     size_t s = (fst.size() <= sec.size() ? fst.size() : sec.size());
     
300.     lr.vec = (fst >= sec ? fst : sec);
     
301.     for (size_t i = 0; i < s; i++)
     
302.     {
     
303.         lr.vec[i] += (tsgn * lsgn) * ((sec <= fst ? sec : fst)[i]);
     
304.     }
     
305.     if ((fst > sec && tsgn < lsgn) || (fst < sec && tsgn > lsgn) || (tsgn == -1 && lsgn == -1))
     
306.     {
     
307.         lr.sign = -1;
     
308.     }
     
309.     if (tsgn*lsgn == -1)
     
310.     {
     
311.         r.Borrow();
     
312.     }
     
313.     r.Carry().ClearZeroVec().VecToStr();
     
314.     lr.nsize = lr.vec.size();
     
315.     return r;
     
316. }
     
317. //符号取反
     
318. const lnum lnum::operator-() const
     
319. {
     
320.     const vector<int> &tvec = num.vec;
     
321.     lnum r = *this;
     
322.     if (tvec != vector<int>(tvec.size(), 0))
     
323.     {
     
324.         r.num.sign = -num.sign;
     
325.     }
     
326.     return r;
     
327. }
     
328. //-
     
329. const lnum lnum::operator-(const lnum &l) const
     
330. {
     
331.     lnum r;
     
332.     if (l.num.vec != vector<int>(1,0))
     
333.     {
     
334.         r = *this + (-l);
     
335.     }
     
336.     else
     
337.     {
     
338.         r = *this;
     
339.     }
     
340.     return r;
     
341. }
     
342. //+=
     
343. const lnum &lnum::operator+=(const lnum &l)
     
344. {
     
345.     *this = *this + l;
     
346.     return *this;
     
347. }
     
348. //前置++
     
349. const lnum &lnum::operator++()
     
350. {
     
351.     return *this += "1";
     
352. }
     
353. //-=
     
354. const lnum &lnum::operator-=(const lnum &l)
     
355. {
     
356.     *this = *this - l;
     
357.     return *this;
     
358. }
     
359. //前置--
     
360. const lnum &lnum::operator--()
     
361. {
     
362.     return *this -= "1";
     
363. }
     
364. //后置++
     
365. const lnum &operator++(lnum &l, const int i)
     
366. {
     
367.     return ++l;
     
368. }
     
369. //后置--
     
370. const lnum &operator--(lnum &l, const int i)
     
371. {
     
372.     return --l;
     
373. }
     
374. //>>
     
375. istream &operator>>(istream &is, lnum &l)
     
376. {
     
377.     string str;
     
378.     (is >> str).get();
     
379.     l = str;
     
380.     return is;
     
381. }
     
382. //<<
     
383. ostream &operator<<(ostream &os, const lnum &l)
     
384. {
     
385.     os << l.AttrToStr();
     
386.     return os;
     
387. }
     

复制代码

test.cpp

1. #include "E:\Users\admin\Documents\VScode\Code\My Class\shape.cpp\lnum\lnum.cpp"
   
2. #include <ctime>
   
3. #include <cmath>
   
4. int main(int argc, char const *argv[])
   
5. {
   
6.     int s = 0;
   
7.     lnum::SetPrecision(6);
   
8.     lnum a, b;
   
9.     char n[20], m[20];
   
10.     n[19] = m[19] = '\0';
    
11.     srand(time(NULL));
    
12.     while (s != 30)
    
13.     {
    
14.         for (size_t i = 0; i < 19; i++)
    
15.         {
    
16.             n[i] = rand() % 9 + 48;
    
17.             
    
18.             m[i] = rand() % 9 + 48;
    
19.         }
    
20.         n[rand() % 15 + 2] = '.';
    
21.         m[rand() % 17 + 2] = '.';
    
22.         if (s % 2 == 0)
    
23.         {
    
24.             n[0] = '-';
    
25.         }
    
26.         if (s % 3 == 0)
    
27.         {
    
28.             m[0] = '-';
    
29.         }
    
30.         a = m;
    
31.         b = n;
    
32.         std::cout << "第" << s << "组" << std::endl;
    
33.         std::cout << a << " - " << b << " = " << (a - b) << "\n"
    
34.                   << a << " + " << b << " = " << (a + b) << "\n\n"
    
35.                   << std::boolalpha
    
36.                   << a << " >  " << b << ": " << (a > b) << "\n\n"
    
37.                   << a << " == " << b << ": " << (a == b) << "\n\n"
    
38.                   << a << " <  " << b << ": " << (a < b) << "\n\n"
    
39.                   << a << " >= " << b << ": " << (a >= b) << "\n\n"
    
40.                   << a << " <= " << b << ": " << (a <= b) << "\n"
    
41.                   << "------------------------------------------------"
    
42.                   << "\n\n";
    
43.         s++;
    
44.     }
    
45.     return 0;
    
46. }
    

复制代码

============================================
Microsoft Windows [版本 10.0.18363.535]
(c) 2019 Microsoft Corporation。保留所有权利。

E:\Users\admin\Documents\VScode\Code>c:\Users\admin\.vscode\extensions\ms-vscode.cpptools-0.26.2\debugAdapters\bin\WindowsDebugLauncher.exe --stdin=Microsoft-MIEngine-In-ftgy2k0d.itp --stdout=Microsoft-MIEngine-Out-ypcddczr.vhp --stderr=Microsoft-MIEngine-Error-aa1im5qa.s4b --pid=Microsoft-MIEngine-Pid-hnjifgnz.bpc --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi
第0组
-3310042360415.7776 - -524736183.452446 = -3309517624232.325154
-3310042360415.7776 + -524736183.452446 = -3310567096599.230046

-3310042360415.7776 >  -524736183.452446: false

-3310042360415.7776 == -524736183.452446: false

-3310042360415.7776 <  -524736183.452446: true

-3310042360415.7776 >= -524736183.452446: false

-3310042360415.7776 <= -524736183.452446: true
------------------------------------------------

第1组
28831215742566646.3 - 5015516270.023648 = 28831210727050376.276352
28831215742566646.3 + 5015516270.023648 = 28831220758082916.323648

28831215742566646.3 >  5015516270.023648: true

28831215742566646.3 == 5015516270.023648: false

28831215742566646.3 <  5015516270.023648: false

28831215742566646.3 >= 5015516270.023648: true

28831215742566646.3 <= 5015516270.023648: false
------------------------------------------------

第2组
8060338.678225 - -84420108108320.115 = 84420116168658.793225
8060338.678225 + -84420108108320.115 = -84420100047981.436775

8060338.678225 >  -84420108108320.115: true

8060338.678225 == -84420108108320.115: false

8060338.678225 <  -84420108108320.115: false

8060338.678225 >= -84420108108320.115: true

8060338.678225 <= -84420108108320.115: false
------------------------------------------------

第3组
-571270373.546517 - 608762417821245.015 = -608762989091618.561517
-571270373.546517 + 608762417821245.015 = 608761846550871.468483

-571270373.546517 >  608762417821245.015: false

-571270373.546517 == 608762417821245.015: false

-571270373.546517 <  608762417821245.015: true

-571270373.546517 >= 608762417821245.015: false

-571270373.546517 <= 608762417821245.015: true
------------------------------------------------

第4组
128261185.021763 - -650.223463 = 128261835.245226
128261185.021763 + -650.223463 = 128260534.798300

128261185.021763 >  -650.223463: true

128261185.021763 == -650.223463: false

128261185.021763 <  -650.223463: false

128261185.021763 >= -650.223463: true

128261185.021763 <= -650.223463: false
------------------------------------------------

第5组
61616.436721 - 33043218771.088144 = -33043157154.651423
61616.436721 + 33043218771.088144 = 33043280387.524865

61616.436721 >  33043218771.088144: false

61616.436721 == 33043218771.088144: false

61616.436721 <  33043218771.088144: true

61616.436721 >= 33043218771.088144: false

61616.436721 <= 33043218771.088144: true
------------------------------------------------

第6组
-870615721.325035 - -185213.632376 = -870430507.692659
-870615721.325035 + -185213.632376 = -870800934.957411

-870615721.325035 >  -185213.632376: false

-870615721.325035 == -185213.632376: false

-870615721.325035 <  -185213.632376: true

-870615721.325035 >= -185213.632376: false

-870615721.325035 <= -185213.632376: true
------------------------------------------------

第7组
1124767517571.72682 - 55438616262.520006 = 1069328901309.206814
1124767517571.72682 + 55438616262.520006 = 1180206133834.246826

1124767517571.72682 >  55438616262.520006: true

1124767517571.72682 == 55438616262.520006: false

1124767517571.72682 <  55438616262.520006: false

1124767517571.72682 >= 55438616262.520006: true

1124767517571.72682 <= 55438616262.520006: false
------------------------------------------------

第8组
323674318651447.714 - -705624841320.74112 = 324379943492768.45512
323674318651447.714 + -705624841320.74112 = 322968693810126.97288

323674318651447.714 >  -705624841320.74112: true

323674318651447.714 == -705624841320.74112: false

323674318651447.714 <  -705624841320.74112: false

323674318651447.714 >= -705624841320.74112: true

323674318651447.714 <= -705624841320.74112: false
------------------------------------------------

第9组
-1144665306707771.6 - 481634332632.706008 = -1145146941040404.306008
-1144665306707771.6 + 481634332632.706008 = -1144183672375138.893992

-1144665306707771.6 >  481634332632.706008: false

-1144665306707771.6 == 481634332632.706008: false

-1144665306707771.6 <  481634332632.706008: true

-1144665306707771.6 >= 481634332632.706008: false

-1144665306707771.6 <= 481634332632.706008: true
------------------------------------------------

第10组
8732.058657 - -782.778583 = 9514.837240
8732.058657 + -782.778583 = 7949.280074

8732.058657 >  -782.778583: true

8732.058657 == -782.778583: false

8732.058657 <  -782.778583: false

8732.058657 >= -782.778583: true

8732.058657 <= -782.778583: false
------------------------------------------------

第11组
25861.444410 - 7026250123802.44388 = -7026250097940.999470
25861.444410 + 7026250123802.44388 = 7026250149663.888290

25861.444410 >  7026250123802.44388: false

25861.444410 == 7026250123802.44388: false

25861.444410 <  7026250123802.44388: true

25861.444410 >= 7026250123802.44388: false

25861.444410 <= 7026250123802.44388: true
------------------------------------------------

第12组
-447.758342 - -22164118630338.377 = 22164118629890.618658
-447.758342 + -22164118630338.377 = -22164118630786.135342

-447.758342 >  -22164118630338.377: true

-447.758342 == -22164118630338.377: false

-447.758342 <  -22164118630338.377: false

-447.758342 >= -22164118630338.377: true

-447.758342 <= -22164118630338.377: false
------------------------------------------------

第13组
8747523615.320310 - 2623811116402745.74 = -2623802368879130.419690
8747523615.320310 + 2623811116402745.74 = 2623819863926361.060310

8747523615.320310 >  2623811116402745.74: false

8747523615.320310 == 2623811116402745.74: false

8747523615.320310 <  2623811116402745.74: true

8747523615.320310 >= 2623811116402745.74: false

8747523615.320310 <= 2623811116402745.74: true
------------------------------------------------

第14组
21.417337 - -841.238130 = 862.655467
21.417337 + -841.238130 = -819.820793

21.417337 >  -841.238130: true

21.417337 == -841.238130: false

21.417337 <  -841.238130: false

21.417337 >= -841.238130: true

21.417337 <= -841.238130: false
------------------------------------------------

第15组
-1540252.622237 - 3301483542760336.28 = -3301483544300588.902237
-1540252.622237 + 3301483542760336.28 = 3301483541220083.657763

-1540252.622237 >  3301483542760336.28: false

-1540252.622237 == 3301483542760336.28: false

-1540252.622237 <  3301483542760336.28: true

-1540252.622237 >= 3301483542760336.28: false

-1540252.622237 <= 3301483542760336.28: true
------------------------------------------------

第16组
804744277.731238 - -57630625470.512714 = 58435369748.243952
804744277.731238 + -57630625470.512714 = -56825881192.781476

804744277.731238 >  -57630625470.512714: true

804744277.731238 == -57630625470.512714: false

804744277.731238 <  -57630625470.512714: false

804744277.731238 >= -57630625470.512714: true

804744277.731238 <= -57630625470.512714: false
------------------------------------------------

第17组
54588025.143467 - 37181153624615.0134 = -37181099036589.869933
54588025.143467 + 37181153624615.0134 = 37181208212640.156867

54588025.143467 >  37181153624615.0134: false

54588025.143467 == 37181153624615.0134: false

54588025.143467 <  37181153624615.0134: true

54588025.143467 >= 37181153624615.0134: false

54588025.143467 <= 37181153624615.0134: true
------------------------------------------------

第18组
-47.444014 - -253.203555 = 205.759541
-47.444014 + -253.203555 = -300.647569

-47.444014 >  -253.203555: true

-47.444014 == -253.203555: false

-47.444014 <  -253.203555: false

-47.444014 >= -253.203555: true

-47.444014 <= -253.203555: false
------------------------------------------------

第19组
6633216310805.67205 - 561852.867423 = 6633215748952.804627
6633216310805.67205 + 561852.867423 = 6633216872658.539473

6633216310805.67205 >  561852.867423: true

6633216310805.67205 == 561852.867423: false

6633216310805.67205 <  561852.867423: false

6633216310805.67205 >= 561852.867423: true

6633216310805.67205 <= 561852.867423: false
------------------------------------------------

第20组
6658841.357124 - -17131451.306243 = 23790292.663367
6658841.357124 + -17131451.306243 = -10472609.949119

6658841.357124 >  -17131451.306243: true

6658841.357124 == -17131451.306243: false

6658841.357124 <  -17131451.306243: false

6658841.357124 >= -17131451.306243: true

6658841.357124 <= -17131451.306243: false
------------------------------------------------

第21组
-200550.220533 - 3284472785364.15405 = -3284472985914.374583
-200550.220533 + 3284472785364.15405 = 3284472584813.933517

-200550.220533 >  3284472785364.15405: false

-200550.220533 == 3284472785364.15405: false

-200550.220533 <  3284472785364.15405: true

-200550.220533 >= 3284472785364.15405: false

-200550.220533 <= 3284472785364.15405: true
------------------------------------------------

第22组
301083560.047325 - -8.655267 = 301083568.702592
301083560.047325 + -8.655267 = 301083551.392058

301083560.047325 >  -8.655267: true

301083560.047325 == -8.655267: false

301083560.047325 <  -8.655267: false

301083560.047325 >= -8.655267: true

301083560.047325 <= -8.655267: false
------------------------------------------------

第23组
148175.157835 - 286266.700022 = -138091.542187
148175.157835 + 286266.700022 = 434441.857857

148175.157835 >  286266.700022: false

148175.157835 == 286266.700022: false

148175.157835 <  286266.700022: true

148175.157835 >= 286266.700022: false

148175.157835 <= 286266.700022: true
------------------------------------------------

第24组
-2621.331256 - -52857260523.474251 = 52857257902.142995
-2621.331256 + -52857260523.474251 = -52857263144.805507

-2621.331256 >  -52857260523.474251: true

-2621.331256 == -52857260523.474251: false

-2621.331256 <  -52857260523.474251: false

-2621.331256 >= -52857260523.474251: true

-2621.331256 <= -52857260523.474251: false
------------------------------------------------

第25组
8773827850628.74812 - 61.476741 = 8773827850567.271379
8773827850628.74812 + 61.476741 = 8773827850690.224861

8773827850628.74812 >  61.476741: true

8773827850628.74812 == 61.476741: false

8773827850628.74812 <  61.476741: false

8773827850628.74812 >= 61.476741: true

8773827850628.74812 <= 61.476741: false
------------------------------------------------

第26组
7351440008672337.43 - -7380726730082.0154 = 7358820735402419.4454
7351440008672337.43 + -7380726730082.0154 = 7344059281942255.4146

7351440008672337.43 >  -7380726730082.0154: true

7351440008672337.43 == -7380726730082.0154: false

7351440008672337.43 <  -7380726730082.0154: false

7351440008672337.43 >= -7380726730082.0154: true

7351440008672337.43 <= -7380726730082.0154: false
------------------------------------------------

第27组
-13383677307.082306 - 3452747742011.25402 = -3466131419318.336326
-13383677307.082306 + 3452747742011.25402 = 3439364064704.171714

-13383677307.082306 >  3452747742011.25402: false

-13383677307.082306 == 3452747742011.25402: false

-13383677307.082306 <  3452747742011.25402: true

-13383677307.082306 >= 3452747742011.25402: false

-13383677307.082306 <= 3452747742011.25402: true
------------------------------------------------

第28组
767613420.170572 - -85462.430530 = 767698882.601102
767613420.170572 + -85462.430530 = 767527957.740042

767613420.170572 >  -85462.430530: true

767613420.170572 == -85462.430530: false

767613420.170572 <  -85462.430530: false

767613420.170572 >= -85462.430530: true

767613420.170572 <= -85462.430530: false
------------------------------------------------

第29组
31813500071.436147 - 6551343.075474 = 31806948728.360673
31813500071.436147 + 6551343.075474 = 31820051414.511621

31813500071.436147 >  6551343.075474: true

31813500071.436147 == 6551343.075474: false

31813500071.436147 <  6551343.075474: false

31813500071.436147 >= 6551343.075474: true

31813500071.436147 <= 6551343.075474: false
------------------------------------------------


E:\Users\admin\Documents\VScode\Code>

bin554385863

2019年12月30日15:00:34

添加新数据
bool  iszero; 判断一个数字字符串是否为0;

struct attr
    {
        int sign = 1; //符号
        bool iszero = true;//默认为true
        size_t dpsize = 0;     //小数位;
        size_t prec = 0;       //精度
        size_t nsize = 1;      //有效位数
        string str = "0";      //过渡字符串
        vector<int> vec = {0}; //数组;
    };

对应新函数

const bool IsZero(const lnum &l) const;

const bool lnum::IsZero(const lnum &l) const
{
    return !((!num.iszero) || (!l.num.iszero));
}

lnum.h

1. #ifndef LNUM_H
   
2. #define LNUM_H
   
3. #include <iostream>
   
4. #include <string>
   
5. #include <vector>
   
6. #include <sstream>
   
7. #include <iomanip>
   
8. using std::istream;
   
9. using std::ostream;
   
10. using std::string;
    
11. using std::stringstream;
    
12. using std::vector;
    
13. class lnum
    
14. {
    
15.     struct attr
    
16.     {
    
17.         int sign = 1; //符号
    
18.         bool iszero = true;
    
19.         size_t dpsize = 0;     //小数位;
    
20.         size_t prec = 0;       //精度
    
21.         size_t nsize = 1;      //有效位数
    
22.         string str = "0";      //过渡字符串
    
23.         vector<int> vec = {0}; //数组;
    
24.     };
    
25.     struct align
    
26.     {
    
27.         vector<int> first;
    
28.         vector<int> second;
    
29.     };
    
30. 
    
31. private:
    
32.     //小数精度;
    
33.     static size_t precision;
    
34.     //数据;
    
35.     attr num;
    
36.     //str to attr
    
37.     const attr StrToAttr(const string &str) const;
    
38.     //attr to str
    
39.     const string AttrToStr() const;
    
40.     //进1
    
41.     lnum &Carry();
    
42.     //借1
    
43.     lnum Borrow();
    
44.     //对齐
    
45.     const align AlignVec(const vector<int> &m, const vector<int> &n) const;
    
46.     //clear zero vec
    
47.     lnum &ClearZeroVec();
    
48.     //vec to str
    
49.     lnum &VecToStr();
    
50.     //iszero
    
51.     const bool IsZero(const lnum &l) const;
    
52. 
    
53. public:
    
54.     lnum(const char *cstr = "0") : num(StrToAttr(cstr)) {}
    
55.     lnum(const string &str) : num(StrToAttr(str)) {}
    
56.     lnum(const lnum &l) : num(l.num) {}
    
57.     //------------------------------------------------------------------
    
58.     //设置精度
    
59.     static void SetPrecision(const size_t i);
    
60.     //展示信息
    
61.     void Showinfo() const;
    
62.     //>
    
63.     const bool operator>(const lnum &l) const;
    
64.     //<
    
65.     const bool operator<(const lnum &l) const;
    
66.     //==
    
67.     const bool operator==(const lnum &l) const;
    
68.     //>=
    
69.     const bool operator>=(const lnum &l) const;
    
70.     //<=
    
71.     const bool operator<=(const lnum &l) const;
    
72.     //+
    
73.     const lnum operator+(const lnum &l) const;
    
74.     //-
    
75.     const lnum operator-(const lnum &l) const;
    
76.     const lnum operator-() const;
    
77.     //+=
    
78.     const lnum &operator+=(const lnum &l);
    
79.     //++
    
80.     const lnum &operator++();
    
81.     //-=
    
82.     const lnum &operator-=(const lnum &l);
    
83.     //--
    
84.     const lnum &operator--();
    
85.     //odject++
    
86.     friend const lnum &operator++(lnum &l, const int i);
    
87.     //object--
    
88.     friend const lnum &operator--(lnum &l, const int i);
    
89.     //>>
    
90.     friend istream &operator>>(istream &is, const lnum &l);
    
91.     //<<
    
92.     friend ostream &operator<<(ostream &os, const lnum &l);
    
93. };
    
94. size_t lnum::precision = 0;
    
95. #endif

复制代码

lnum.cpp

1. #include "E:\Users\admin\Documents\VScode\Code\My Class\shape.cpp\lnum\lnum.h"
   
2. //str to attr
   
3. const lnum::attr lnum::StrToAttr(const string &str) const
   
4. {
   
5.     attr n;
   
6.     n.prec = precision;
   
7.     n.str = str;
   
8.     string &nstr = n.str;
   
9.     size_t &ndps = n.dpsize, &npre = n.prec;
   
10.     if (nstr[0] == '-')
    
11.     {
    
12.         nstr.erase(0, 1);
    
13.     }
    
14.     if (int(nstr.find('.')) != -1)
    
15.     {
    
16.         nstr.erase(nstr.find('.'), 1);
    
17.     }
    
18.     if (nstr == string(nstr.size(), '0'))
    
19.     {
    
20.         nstr.clear();
    
21.         nstr.push_back('0');
    
22.     }
    
23.     else //if (nstr != string(nstr.size(), '0'))
    
24.     {
    
25.         
    
26.         n.iszero = false;//iszero
    
27.         size_t s = nstr.size(), i = 0;
    
28.         if (str[0] == '-')
    
29.         {
    
30.             n.sign = -1;
    
31.         }
    
32.         if (int(str.find('.')) != -1)
    
33.         {
    
34.             ndps = str.size() - str.find('.') - 1;
    
35.             if (nstr[0] == '0')
    
36.             {
    
37. 
    
38.                 for (; i < s; i++)
    
39.                 {
    
40.                     if (nstr[i] != '0')
    
41.                     {
    
42.                         break;
    
43.                     }
    
44.                 }
    
45.                 if (i >= s - ndps)
    
46.                 {
    
47.                     nstr.erase(0, s - ndps - 1);
    
48.                 }
    
49.                 else if (i < s - ndps)
    
50.                 {
    
51.                     nstr.erase(0, i);
    
52.                 }
    
53.             }
    
54.         }
    
55.         else
    
56.         {
    
57.             if (nstr[0] == '0')
    
58.             {
    
59.                 for (i = 0; i < s; i++)
    
60.                 {
    
61.                     if (nstr[i] != '0')
    
62.                     {
    
63.                         break;
    
64.                     }
    
65.                 }
    
66.                 nstr.erase(0, i);
    
67.             }
    
68.         }
    
69.         if (npre > ndps)
    
70.         {
    
71.             nstr.insert(nstr.end(), npre - ndps, '0');
    
72.         }
    
73.         else if (npre < ndps)
    
74.         {
    
75.             nstr.erase(nstr.size() - (ndps - npre));
    
76.             ndps = npre;
    
77.         }
    
78.         n.vec.clear();
    
79.         for (char c : nstr)
    
80.         {
    
81.             n.vec.push_back(c - 48);
    
82.         }
    
83.         n.nsize = nstr.size();
    
84.     }
    
85.     return n;
    
86. }
    
87. //attr to str
    
88. const string lnum::AttrToStr() const
    
89. {
    
90.     string t = num.str, &str = t;
    
91.     const size_t &prec = num.prec, &dpsize = num.dpsize;
    
92.     if (prec != 0 && str.size() != 1)
    
93.     {
    
94.         if (dpsize == prec)
    
95.         {
    
96.             str.insert(str.size() - prec, 1, '.');
    
97.         }
    
98.         else if (dpsize < prec && dpsize != 0)
    
99.         {
    
100.             str.erase(str.size() - (prec - dpsize));
     
101.             str.insert(str.size() - dpsize, 1, '.');
     
102.         }
     
103.         else if (dpsize == 0)
     
104.         {
     
105.             str.erase(str.size() - prec);
     
106.         }
     
107.     }
     
108.     if (num.sign == -1)
     
109.     {
     
110.         str.insert(0, 1, '-');
     
111.     }
     
112.     return str;
     
113. }
     
114. //进1
     
115. lnum &lnum::Carry()
     
116. {
     
117.     vector<int> &v = num.vec;
     
118.     v.insert(v.begin(), 1, 0);
     
119.     size_t s = v.size();
     
120.     for (size_t i = s - 1; i > 0; i--)
     
121.     {
     
122.         int t = v[i];
     
123.         v[i] = t % 10;
     
124.         v[i - 1] += t / 10;
     
125.     }
     
126.     return *this;
     
127. }
     
128. //借1
     
129. lnum lnum::Borrow()
     
130. {
     
131.     vector<int> &v = num.vec;
     
132.     size_t s = v.size();
     
133.     for (size_t i = 1; i < s; i++)
     
134.     {
     
135.         v[i - 1] -= 1;
     
136.         v[i] += 10;
     
137.     }
     
138.     return *this;
     
139. }
     
140. //对齐
     
141. const lnum::align lnum::AlignVec(const vector<int> &m, const vector<int> &n) const
     
142. {
     
143.     align agn;
     
144.     vector<int> &fst = agn.first, &sec = agn.second;
     
145.     fst = m, sec = n;
     
146.     size_t fsize = fst.size(), ssize = sec.size();
     
147.     if (fsize < ssize)
     
148.     {
     
149.         fst.insert(fst.begin(), ssize - fsize, 0);
     
150.     }
     
151.     else if (fsize > ssize)
     
152.     {
     
153.         sec.insert(sec.begin(), fsize - ssize, 0);
     
154.     }
     
155.     return agn;
     
156. }
     
157. //clear zero vec
     
158. lnum &lnum::ClearZeroVec()
     
159. {
     
160.     const size_t &prec = num.prec;
     
161.     vector<int> &v = num.vec;
     
162.    
     
163.     if (num.iszero)//v == vector<int>(v.size(), 0)
     
164.     {
     
165.         v.clear();
     
166.         v.push_back(0);
     
167.     }
     
168.     else if (v[0] == 0)
     
169.     {
     
170.         size_t s = v.size(), i = 0;
     
171.         if (prec != 0)
     
172.         {
     
173. 
     
174.             for (; i < s; i++)
     
175.             {
     
176.                 if (v[i] != 0)
     
177.                 {
     
178.                     break;
     
179.                 }
     
180.             }
     
181.             if (i >= s - prec)
     
182.             {
     
183.                 v.erase(v.begin(), v.begin() + (s - prec - 1));
     
184.             }
     
185.             else if (i < s - prec)
     
186.             {
     
187.                 v.erase(v.begin(), v.begin() + i);
     
188.             }
     
189.         }
     
190.         else
     
191.         {
     
192.             for (i = 0; i < s; i++)
     
193.             {
     
194.                 if (v[i] != 0)
     
195.                 {
     
196.                     break;
     
197.                 }
     
198.             }
     
199.             v.erase(v.begin(), v.begin() + i);
     
200.         }
     
201.     }
     
202.     return *this;
     
203. }
     
204. //vec to str
     
205. lnum &lnum::VecToStr()
     
206. {
     
207.     num.str.clear();
     
208.     for (int i : num.vec)
     
209.     {
     
210.         num.str.push_back(i + 48);
     
211.     }
     
212.     return *this;
     
213. }
     
214. //iszero
     
215. const bool lnum::IsZero(const lnum &l) const
     
216. {
     
217.     return !((!num.iszero) || (!l.num.iszero));
     
218. }
     
219. //------------------------------------------------------------------------
     
220. //设置精度
     
221. void lnum::SetPrecision(const size_t i)
     
222. {
     
223.     lnum::precision = i;
     
224. }
     
225. //展示信息
     
226. void lnum::Showinfo() const
     
227. {
     
228.     std::cout << "有效数位: ";
     
229.     for (int i : num.vec)
     
230.     {
     
231.         std::cout << i << " ";
     
232.     }
     
233.     std::cout << std::endl;
     
234.     std::cout << "正负符号: " << num.sign << "\n"
     
235.               << std::boolalpha << "是否为零: " << num.iszero << "\n"
     
236.               << "小数位数: " << num.dpsize << "\n"
     
237.               << "小数精度: " << num.prec << "\n"
     
238.               << "有效位数: " << num.nsize << std::endl;
     
239. }
     
240. //>
     
241. const bool lnum::operator>(const lnum &l) const
     
242. {
     
243.     bool f = true;
     
244.     align agn = AlignVec(num.vec, l.num.vec);
     
245.     const vector<int> &fst = agn.first, &sec = agn.second;
     
246.     if (num.sign < l.num.sign)
     
247.     {
     
248.         f = false;
     
249.     }
     
250.     if (num.sign == l.num.sign)
     
251.     {
     
252.         f = fst > sec;
     
253.         if (num.sign == -1)
     
254.         {
     
255.             f = !f;
     
256.         }
     
257.     }
     
258.     return f;
     
259. }
     
260. //<
     
261. const bool lnum::operator<(const lnum &l) const
     
262. {
     
263.     bool f = true;
     
264.     align agn = AlignVec(num.vec, l.num.vec);
     
265.     const vector<int> &fst = agn.first, &sec = agn.second;
     
266.     if (num.sign > l.num.sign)
     
267.     {
     
268.         f = false;
     
269.     }
     
270.     if (num.sign == l.num.sign)
     
271.     {
     
272.         f = fst < sec;
     
273.         if (num.sign == -1)
     
274.         {
     
275.             f = !f;
     
276.         }
     
277.     }
     
278.     return f;
     
279. }
     
280. //==
     
281. const bool lnum::operator==(const lnum &l) const
     
282. {
     
283.     align agn = AlignVec(num.vec, l.num.vec);
     
284.     const vector<int> &fst = agn.first, &sec = agn.second;
     
285.     return fst == sec && num.sign == l.num.sign;
     
286. }
     
287. //>=
     
288. const bool lnum::operator>=(const lnum &l) const
     
289. {
     
290.     return !(*this < l);
     
291. }
     
292. //<=
     
293. const bool lnum::operator<=(const lnum &l) const
     
294. {
     
295.     return !(*this > l);
     
296. }
     
297. //+
     
298. const lnum lnum::operator+(const lnum &l) const
     
299. {
     
300. 
     
301.     lnum r;
     
302.     attr &lr = r.num;
     
303.     lr.iszero = this->IsZero(l);
     
304.     const align &agn = AlignVec(num.vec, l.num.vec);
     
305.     const int &tsgn = num.sign, &lsgn = l.num.sign;
     
306.     const vector<int> &fst = agn.first, &sec = agn.second, &tvec = num.vec, &lvec = l.num.vec;
     
307.     lr.prec = num.prec;
     
308.     lr.dpsize = (num.dpsize >= l.num.dpsize ? num.dpsize : l.num.dpsize);
     
309.     size_t s = (fst.size() <= sec.size() ? fst.size() : sec.size());
     
310.     lr.vec = (fst >= sec ? fst : sec);
     
311.     for (size_t i = 0; i < s; i++)
     
312.     {
     
313.         lr.vec[i] += (tsgn * lsgn) * ((sec <= fst ? sec : fst)[i]);
     
314.     }
     
315.     if ((fst > sec && tsgn < lsgn) || (fst < sec && tsgn > lsgn) || (tsgn == -1 && lsgn == -1))
     
316.     {
     
317.         lr.sign = -1;
     
318.     }
     
319.     if (tsgn * lsgn == -1)
     
320.     {
     
321.         r.Borrow();
     
322.     }
     
323.     r.Carry().ClearZeroVec().VecToStr();
     
324.     lr.nsize = lr.vec.size();
     
325.     return r;
     
326. }
     
327. //符号取反
     
328. const lnum lnum::operator-() const
     
329. {
     
330.     const vector<int> &tvec = num.vec;
     
331.     lnum r = *this;
     
332.     if (num.iszero == false)//(tvec != vector<int>(tvec.size(), 0))
     
333.     {
     
334.         r.num.sign = -num.sign;
     
335.     }
     
336.     return r;
     
337. }
     
338. //-
     
339. const lnum lnum::operator-(const lnum &l) const
     
340. {
     
341.     lnum r;
     
342.     r.num.iszero = this->IsZero(l);
     
343.     if (l.num.iszero == false)//(l.num.vec != vector<int>(1, 0))
     
344.     {
     
345.         r = *this + (-l);
     
346.     }
     
347.     else
     
348.     {
     
349.         r = *this;
     
350.     }
     
351.     return r;
     
352. }
     
353. //+=
     
354. const lnum &lnum::operator+=(const lnum &l)
     
355. {
     
356.     *this = *this + l;
     
357.     return *this;
     
358. }
     
359. //前置++
     
360. const lnum &lnum::operator++()
     
361. {
     
362.     return *this += "1";
     
363. }
     
364. //-=
     
365. const lnum &lnum::operator-=(const lnum &l)
     
366. {
     
367.     *this = *this - l;
     
368.     return *this;
     
369. }
     
370. //前置--
     
371. const lnum &lnum::operator--()
     
372. {
     
373.     return *this -= "1";
     
374. }
     
375. //后置++
     
376. const lnum &operator++(lnum &l, const int i)
     
377. {
     
378.     return ++l;
     
379. }
     
380. //后置--
     
381. const lnum &operator--(lnum &l, const int i)
     
382. {
     
383.     return --l;
     
384. }
     
385. //>>
     
386. istream &operator>>(istream &is, lnum &l)
     
387. {
     
388.     string str;
     
389.     (is >> str).get();
     
390.     l = str;
     
391.     return is;
     
392. }
     
393. //<<
     
394. ostream &operator<<(ostream &os, const lnum &l)
     
395. {
     
396.     os << l.AttrToStr();
     
397.     return os;
     
398. }
     

复制代码

test.cpp

1. #include "E:\Users\admin\Documents\VScode\Code\My Class\shape.cpp\lnum\lnum.cpp"
   
2. #include <ctime>
   
3. #include <cmath>
   
4. int main(int argc, char const *argv[])
   
5. {
   
6.     int s = 0;
   
7.     lnum::SetPrecision(6);
   
8.     lnum a, b;
   
9.     char n[9], m[9];
   
10.     n[8] = m[8] = '\0';
    
11.     srand(time(NULL));
    
12.     while (s != 12)
    
13.     {
    
14.         for (size_t i = 0; i < 8; i++)
    
15.         {
    
16.             n[i] = rand() % 9 + 48;
    
17. 
    
18.             m[i] = rand() % 9 + 48;
    
19.         }
    
20.         n[rand() % 6 + 1] = '.';
    
21.         m[rand() % 6 + 1] = '.';
    
22.         if (s % 2 == 0)
    
23.         {
    
24.             n[0] = '-';
    
25.         }
    
26.         if (s % 3 == 0)
    
27.         {
    
28.             m[0] = '-';
    
29.         }
    
30.         a = m;
    
31.         b = n;
    
32.         std::cout << "第" << s << "组" << std::endl;
    
33.         std::cout << a << " - " << b << " = " << (a - b) << "\n"
    
34.                   << a << " + " << b << " = " << (a + b) << "\n\n"
    
35.                   << std::boolalpha
    
36.                   << a << " >  " << b << ": " << (a > b) << "\n\n"
    
37.                   << a << " == " << b << ": " << (a == b) << "\n\n"
    
38.                   << a << " <  " << b << ": " << (a < b) << "\n\n"
    
39.                   << a << " >= " << b << ": " << (a >= b) << "\n\n"
    
40.                   << a << " <= " << b << ": " << (a <= b) << "\n"
    
41.                   << "------------------------------------------------"
    
42.                   << "\n\n";
    
43.         s++;
    
44.     }
    
45.     return 0;
    
46. }
    

复制代码

---------------------------------------------------------------------------------------------
Microsoft Windows [版本 10.0.18363.535]
(c) 2019 Microsoft Corporation。保留所有权利。

E:\Users\admin\Documents\VScode\Code>c:\Users\admin\.vscode\extensions\ms-vscode.cpptools-0.26.2\debugAdapters\bin\WindowsDebugLauncher.exe --stdin=Microsoft-MIEngine-In-r4eqqtl4.g4x --stdout=Microsoft-MIEngine-Out-tdxveute.slr --stderr=Microsoft-MIEngine-Error-mmf3t4g3.0vo --pid=Microsoft-MIEngine-Pid-ube4pyyu.txb --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi
第0组
-65066.5 - -28541.3 = -36525.2
-65066.5 + -28541.3 = -93607.8

-65066.5 >  -28541.3: false   

-65066.5 == -28541.3: false   

-65066.5 <  -28541.3: true   

-65066.5 >= -28541.3: false

-65066.5 <= -28541.3: true
------------------------------------------------

第1组
45.31752 - 86.42017 = -41.10265
45.31752 + 86.42017 = 131.73769

45.31752 >  86.42017: false

45.31752 == 86.42017: false

45.31752 <  86.42017: true

45.31752 >= 86.42017: false

45.31752 <= 86.42017: true
------------------------------------------------

第2组
5.601777 - -65.7413 = 71.343077
5.601777 + -65.7413 = -60.139523

5.601777 >  -65.7413: true

5.601777 == -65.7413: false

5.601777 <  -65.7413: false

5.601777 >= -65.7413: true

5.601777 <= -65.7413: false
------------------------------------------------

第3组
-6618.72 - 581607.6 = -588226.32
-6618.72 + 581607.6 = 574988.88

-6618.72 >  581607.6: false

-6618.72 == 581607.6: false

-6618.72 <  581607.6: true

-6618.72 >= 581607.6: false

-6618.72 <= 581607.6: true
------------------------------------------------

第4组
36812.51 - -27147.1 = 63959.61
36812.51 + -27147.1 = 9665.41

36812.51 >  -27147.1: true

36812.51 == -27147.1: false

36812.51 <  -27147.1: false

36812.51 >= -27147.1: true

36812.51 <= -27147.1: false
------------------------------------------------

第5组
445684.7 - 4821.640 = 440863.060
445684.7 + 4821.640 = 450506.340

445684.7 >  4821.640: true

445684.7 == 4821.640: false

445684.7 <  4821.640: false

445684.7 >= 4821.640: true

445684.7 <= 4821.640: false
------------------------------------------------

第6组
-.650710 - -4.45786 = 3.807150
-.650710 + -4.45786 = -5.108570

-.650710 >  -4.45786: true

-.650710 == -4.45786: false

-.650710 <  -4.45786: false

-.650710 >= -4.45786: true

-.650710 <= -4.45786: false
------------------------------------------------

第7组
154.2605 - 350.4061 = -196.1456
154.2605 + 350.4061 = 504.6666

154.2605 >  350.4061: false

154.2605 == 350.4061: false

154.2605 <  350.4061: true

154.2605 >= 350.4061: false

154.2605 <= 350.4061: true
------------------------------------------------

第8组
47.87481 - -5507.32 = 5555.19481
47.87481 + -5507.32 = -5459.44519

47.87481 >  -5507.32: true

47.87481 == -5507.32: false

47.87481 <  -5507.32: false

47.87481 >= -5507.32: true

47.87481 <= -5507.32: false
------------------------------------------------

第9组
-653.76 - 680005.7 = -680659.46
-653.76 + 680005.7 = 679351.94

-653.76 >  680005.7: false

-653.76 == 680005.7: false

-653.76 <  680005.7: true

-653.76 >= 680005.7: false

-653.76 <= 680005.7: true
------------------------------------------------

第10组
462520.0 - -28804.2 = 491324.2
462520.0 + -28804.2 = 433715.8

462520.0 >  -28804.2: true

462520.0 == -28804.2: false

462520.0 <  -28804.2: false

462520.0 >= -28804.2: true

462520.0 <= -28804.2: false
------------------------------------------------

第11组
746407.4 - 150352.6 = 596054.8
746407.4 + 150352.6 = 896760.0

746407.4 >  150352.6: true

746407.4 == 150352.6: false

746407.4 <  150352.6: false

746407.4 >= 150352.6: true

746407.4 <= 150352.6: false
------------------------------------------------


E:\Users\admin\Documents\VScode\Code>