字符串计算第二版

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.     typedef vector<int> vecint;
    
13.     struct attr
    
14.     {
    
15.         string str;
    
16.         int sign;
    
17.         vecint vec;
    
18.         size_t nsize, dsize;
    
19.     };
    
20.     struct align
    
21.     {
    
22.         vecint first, second;
    
23.     };
    
24.    
    
25. private:
    
26.     attr num;
    
27.     static size_t precision;
    
28.     //初始化构造函数的数据
    
29.     const attr InitData(const string &s);
    
30.     //判断是否有效的数字字符串
    
31.     const bool IsNumStr(const string &s) const;
    
32.     //判断字符串元素是否全为'0'
    
33.     const bool IsStrElemZero(const string &s) const;
    
34.     //清除无效的0
    
35.     const string ClearStrZero(const string &s) const;
    
36.     //获取正负符号
    
37.     const int getSign(const string &s) const;
    
38.     //获取数组
    
39.     const vecint Str2Vec(const string &s) const;
    
40.     //获取数字字符串
    
41.     const string Vec2Str(const vecint &v, int sgn, size_t dps) const;
    
42.     //获取小数位数
    
43.     const size_t getDpsize(const string &s) const;
    
44.     //整体对齐
    
45.     const align nAlign(const lnum &l) const;
    
46.     //小数位对齐
    
47.     const align dAlign(const lnum &l) const;
    
48.     //满十进一
    
49.     void Carry(vecint &v) const;
    
50.     //借一
    
51.     void Borrow(vecint &v) const;
    
52.     //数组乘整数
    
53.     lnum operator*(const int i) const;
    
54. 
    
55. public:
    
56.     lnum(const char *cstr = "0") : num(InitData(cstr)) {}
    
57.     lnum(const string &s) : num(InitData(s)) {}
    
58.     lnum(const lnum &l) : num(l.num) {}
    
59.     void showinfo() const;
    
60.     //(1)重载>
    
61.     const bool operator>(const lnum &l) const;
    
62.     //(2)重载==
    
63.     const bool operator==(const lnum &l) const;
    
64.     //(2.5)重载!=
    
65.     const bool operator!=(const lnum &l) const;
    
66.     //(3)重载>=
    
67.     const bool operator>=(const lnum &l) const;
    
68.     //(4)重载<
    
69.     const bool operator<(const lnum &l) const;
    
70.     //(5)重载<=
    
71.     const bool operator<=(const lnum &l) const;
    
72.     //(6)重载+
    
73.     const lnum operator+(const lnum &l) const;
    
74.     //(7)重载-,反转正负
    
75.     const lnum operator-() const;
    
76.     void static setprecision(const unsigned i);
    
77.     friend ostream &operator<<(ostream &os, const lnum &l);
    
78.     friend istream &operator>>(istream &is, lnum &l);
    
79.     virtual ~lnum() {}
    
80. };
    
81. size_t lnum::precision = 3;
    
82. #endif

复制代码

lnum.cpp

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

复制代码

=======================================================================

1. #include "E:\Users\admin\Documents\VScode\Code\My Class\largenum\lnum.cpp"
   
2. int main(int argc, char const *argv[])
   
3. {
   
4.     lnum a = "-5.000009", b = "6000";
   
5.     std::cout << (a + b) << std::endl;
   
6.     (a + b).showinfo();
   
7.     return 0;
   
8. }

复制代码

--------------------------------------------------------------------------------------------------
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-tmgi4wns.nfx --stdout=Microsoft-MIEngine-Out-sz504ytr.rqz --stderr=Microsoft-MIEngine-Error-ni2x4gi1.12t --pid=Microsoft-MIEngine-Pid-mtm4v2ay.ggn --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi
5994.999991
正/负/零: 1
原始字符: 5994.999991
数字元素: 5 9 9 4 9 9 9 9 9 1
数字长度: 10
小数位数: 6

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

bin554385863

__优化代码
__添加算法
__实现精度输出

lnum.cpp

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.     typedef vector<int> vecint;
    
13.     struct attr
    
14.     {
    
15.         string str = "0";
    
16.         int sign = 0;
    
17.         vecint vec = {0};
    
18.         size_t nsize = 1, dsize = 0;
    
19.     };
    
20.     struct align
    
21.     {
    
22.         vecint first, second;
    
23.     };
    
24.    
    
25. private:
    
26.     attr num;
    
27.     static size_t precision;
    
28.     //初始化构造函数的数据
    
29.     const attr InitData(const string &s);
    
30.     //判断是否有效的数字字符串
    
31.     const bool IsNumStr(const string &s) const;
    
32.     //判断字符串元素是否全为'0'
    
33.     const bool IsStrElemZero(const string &s) const;
    
34.     //清除无效的0
    
35.     const string ClearStrZero(const string &s) const;
    
36.     //获取正负符号
    
37.     const int getSign(const string &s) const;
    
38.     //获取数组
    
39.     const vecint Str2Vec(const string &s) const;
    
40.     //获取数字字符串
    
41.     const string Vec2Str(const vecint &v, int sgn, size_t dps) const;
    
42.     //获取小数位数
    
43.     const size_t getDsize(const string &s) const;
    
44.     //整体对齐
    
45.     const align nAlign(const lnum &l) const;
    
46.     //小数位对齐
    
47.     const align dAlign(const lnum &l) const;
    
48.     //满十进一
    
49.     void Carry(vecint &v) const;
    
50.     //借一
    
51.     void Borrow(vecint &v) const;
    
52.     //数组乘整数
    
53.     lnum operator*(const int i) const;
    
54.     //输出字符串
    
55.     const string outPutStr() const;
    
56. 
    
57. public:
    
58. 
    
59.     lnum(const char *cstr = "0") : num(InitData(cstr)) {}
    
60.     lnum(const string &s) : num(InitData(s)) {}
    
61.     lnum(const lnum &l) : num(l.num) {}
    
62.     void showinfo() const;
    
63.     //(1)重载>
    
64.     const bool operator>(const lnum &l) const;
    
65.     //(2)重载==
    
66.     const bool operator==(const lnum &l) const;
    
67.     //(2.5)重载!=
    
68.     const bool operator!=(const lnum &l) const;
    
69.     //(3)重载>=
    
70.     const bool operator>=(const lnum &l) const;
    
71.     //(4)重载<
    
72.     const bool operator<(const lnum &l) const;
    
73.     //(5)重载<=
    
74.     const bool operator<=(const lnum &l) const;
    
75.     //(6)重载+
    
76.     const lnum operator+(const lnum &l) const;
    
77.     //(7)重载-,反转正负
    
78.     const lnum operator-() const;
    
79.     //(8)重载-
    
80.     const lnum operator-(const lnum &l) const;
    
81.     //(9)重载+=
    
82.     const lnum &operator+=(const lnum &l);
    
83.     //(10)重载++
    
84.     const lnum &operator++();
    
85.     //(11)重载-=
    
86.     const lnum &operator-=(const lnum &l);
    
87.     //(12)重载--
    
88.     const lnum &operator--();
    
89.     //(13)前置++
    
90.     friend const lnum &operator++(lnum &l, const int i);
    
91.     //(14)前置--
    
92.     friend const lnum &operator--(lnum &l, const int i);
    
93.     void static setprecision(const unsigned i);
    
94.     friend ostream &operator<<(ostream &os, const lnum &l);
    
95.     friend istream &operator>>(istream &is, lnum &l);
    
96.     virtual ~lnum() {}
    
97. };
    
98. size_t lnum::precision = 0;
    
99. #endif

复制代码

lnum.cpp

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

复制代码

=====================================================================

main.cpp

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

复制代码

=================================================================================
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-yrdvjqxw.52e --stdout=Microsoft-MIEngine-Out-l05gzt3v.anm --stderr=Microsoft-MIEngine-Error-cyag0fjm.qse --pid=Microsoft-MIEngine-Pid-42rglrua.ou0 --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi
第0组
a = -3.08  b = -38.58
--------------------------------------------------      
a >  b: true
a == b: false
a <  b: false
--------------------------------------------------------
a +  b = -41.66
a -  b = 35.5
=======================================================
第1组
a = 407.56  b = 601.42
--------------------------------------------------
a >  b: false
a == b: false
a <  b: true
--------------------------------------------------------
a +  b = 1008.98
a -  b = -193.86
=======================================================
第2组
a = -6.366  b = 72.44
--------------------------------------------------
a >  b: false
a == b: false
a <  b: true
--------------------------------------------------------
a +  b = 66.074
a -  b = -78.806
=======================================================
第3组
a = 652.88  b = -1.731
--------------------------------------------------
a >  b: true
a == b: false
a <  b: false
--------------------------------------------------------
a +  b = 651.149
a -  b = 654.611
=======================================================
第4组
a = -1.467  b = 745.22
--------------------------------------------------
a >  b: false
a == b: false
a <  b: true
--------------------------------------------------------
a +  b = 743.753
a -  b = -746.687
=======================================================
第5组
a = 842.55  b = 63.016
--------------------------------------------------
a >  b: true
a == b: false
a <  b: false
--------------------------------------------------------
a +  b = 905.566
a -  b = 779.534
=======================================================
第6组
a = -46.87  b = -4.057
--------------------------------------------------
a >  b: false
a == b: false
a <  b: true
--------------------------------------------------------
a +  b = -50.927
a -  b = -42.813
=======================================================
第7组
a = 10.748  b = 752.88
--------------------------------------------------
a >  b: false
a == b: false
a <  b: true
--------------------------------------------------------
a +  b = 763.628
a -  b = -742.132
=======================================================
第8组
a = -1.506  b = 804.61
--------------------------------------------------
a >  b: false
a == b: false
a <  b: true
--------------------------------------------------------
a +  b = 803.104
a -  b = -806.116
=======================================================
第9组
a = 2.626  b = -6.542
--------------------------------------------------
a >  b: true
a == b: false
a <  b: false
--------------------------------------------------------
a +  b = -3.916
a -  b = 9.168
=======================================================

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

bin554385863

lnum.h

1. /*
   
2. (1)原始数字字符串->清除无效的零->转换数组,提取信息(小数位数,整数位数,是否为零);
   
3. (2)整体对齐->比较大小,设计加/减法;
   
4. (3)小数位对齐->设计数组乘整数->设计数组乘数组->实现对象乘法;
   
5. (补充)实现满十进一,退一借十;
   
6. */
   
7. #ifndef LNUM_H
   
8. #define LNUM_H
   
9. #include <iostream>
   
10. #include <string>
    
11. #include <vector>
    
12. using std::istream;
    
13. using std::ostream;
    
14. using std::string;
    
15. using std::vector;
    
16. class lnum
    
17. {
    
18.     struct ndata
    
19.     {
    
20.         int sign;
    
21.         string nstr;
    
22.         vector<int> nvec;
    
23.         size_t isize, dsize;
    
24.     };
    
25.     struct align
    
26.     {
    
27.         vector<int> first, second;
    
28.     };
    
29.    
    
30. private:
    
31.     static size_t pre;
    
32.     ndata data;
    
33.     //(0)判断是否含有小数点
    
34.     const bool hasDecPoint(const string &s) const;
    
35.     //(1)判断字符串是否有效
    
36.     const bool isInvalidStr(const string &s) const;
    
37.     //(2)判断字符串元素是否全为零
    
38.     const bool isStrElemAllZero(const string &s) const;
    
39.     //(3)清除无效的零
    
40.     const string clearInvalidZero(const string &s) const;
    
41.     //(4)转换数组
    
42.     const vector<int> strToVec(const string &s) const;
    
43.     //(-4)转换字符串
    
44.     const string vecToStr(const vector<int> &vint, int sgn, size_t dsz) const;
    
45.     //(5)提取信息
    
46.     const ndata getInfo(const string &s) const;
    
47.     //(6)小数位对齐
    
48.     align dAlign(const lnum &l) const;
    
49.     //(7)整体对齐
    
50.     align wAlign(const lnum &l) const;
    
51.     //(8)满十进一
    
52.     void carry(vector<int> &v) const;
    
53.     //(9)借一补十
    
54.     void borrow(vector<int> &v) const;
    
55. 
    
56. public:
    
57.     lnum(const char *cstr = "0") : data(getInfo(cstr)){}
    
58.     lnum(const string &s):data(getInfo(s)){}
    
59.     void showinfo() const;
    
60.     //(1)>号
    
61.     const bool operator>(const lnum &l) const;
    
62.     //(2)==
    
63.     const bool operator==(const lnum &l) const;
    
64.     //(3)>=
    
65.     const bool operator>=(const lnum &l) const;
    
66.     //(4)<
    
67.     const bool operator<(const lnum &l) const;
    
68.     //(5)<=
    
69.     const bool operator<=(const lnum &l) const;
    
70.     //(5)!=
    
71.     const bool operator!=(const lnum &l) const;
    
72.     //(6)+
    
73.     const lnum operator+(const lnum &l) const;
    
74.     //(7)-反转正负
    
75.     const lnum operator-() const;
    
76.     //(F)<<
    
77.     friend ostream &operator<<(ostream &os, const lnum &l);
    
78. };
    
79. #endif

复制代码

lnum.cpp

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

复制代码

bin554385863

继续优化

lnum.h

1. /*
   
2. (1)原始数字字符串->清除无效的零->转换数组,提取信息(小数位数,整数位数,是否为零);
   
3. (2)整体对齐->比较大小,设计加/减法;
   
4. (3)小数位对齐->设计数组乘整数->设计数组乘数组->实现对象乘法;
   
5. (补充)实现满十进一,退一借十;
   
6. */
   
7. #ifndef LNUM_H
   
8. #define LNUM_H
   
9. #include <iostream>
   
10. #include <string>
    
11. #include <vector>
    
12. using std::istream;
    
13. using std::ostream;
    
14. using std::string;
    
15. using std::vector;
    
16. class lnum
    
17. {
    
18.     struct ndata
    
19.     {
    
20.         int sign;
    
21.         string nstr;
    
22.         vector<int> nvec;
    
23.         size_t isize, dsize;
    
24.     };
    
25.     struct align
    
26.     {
    
27.         vector<int> first, second;
    
28.     };
    
29.    
    
30. private:
    
31.     static size_t pre;
    
32.     ndata data;
    
33.     //(0)判断是否含有小数点
    
34.     const bool hasDecPoint(const string &s) const;
    
35.     //(1)判断字符串是否有效
    
36.     const bool isInvalidStr(const string &s) const;
    
37.     //(2)判断字符串元素是否全为零
    
38.     const bool isStrElemAllZero(const string &s) const;
    
39.     //(3)清除无效的零
    
40.     const string clearInvalidZero(const string &s) const;
    
41.     //(4)转换数组
    
42.     const vector<int> strToVec(const string &s) const;
    
43.     //(-4)转换字符串
    
44.     const string vecToStr(const vector<int> &vint, int sgn, size_t dsz) const;
    
45.     //(5)提取信息
    
46.     const ndata getInfo(const string &s) const;
    
47.     //(6)小数位对齐
    
48.     align dAlign(const lnum &l) const;
    
49.     //(7)整体对齐
    
50.     align wAlign(const lnum &l) const;
    
51.     //(8)满十进一
    
52.     void carry(vector<int> &v) const;
    
53.     //(9)借一补十
    
54.     void borrow(vector<int> &v) const;
    
55.     //(10)截断输出
    
56.     const string outPut() const;
    
57. 
    
58. public:
    
59.     lnum(const char *cstr = "0") : data(getInfo(cstr)){}
    
60.     lnum(const string &s):data(getInfo(s)){}
    
61.     void showinfo() const;
    
62.     static void setprecision(const size_t p);
    
63.     //(1)>号
    
64.     const bool operator>(const lnum &l) const;
    
65.     //(2)==
    
66.     const bool operator==(const lnum &l) const;
    
67.     //(3)>=
    
68.     const bool operator>=(const lnum &l) const;
    
69.     //(4)<
    
70.     const bool operator<(const lnum &l) const;
    
71.     //(5)<=
    
72.     const bool operator<=(const lnum &l) const;
    
73.     //(5)!=
    
74.     const bool operator!=(const lnum &l) const;
    
75.     //(6)+
    
76.     const lnum operator+(const lnum &l) const;
    
77.     //(7)-反转正负
    
78.     const lnum operator-() const;
    
79.     //(F)<<
    
80.     friend ostream &operator<<(ostream &os, const lnum &l);
    
81.     //(F)>>
    
82.     friend istream &operator>>(istream &is, lnum &l);
    
83. };
    
84. size_t lnum::pre = 6;
    
85. #endif

复制代码

lnum.cpp

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

复制代码

bin554385863

添加减法
const lnum operator-(const lnum &l) const;

1. const lnum lnum::operator-(const lnum &l) const
   
2. {
   
3.     return *this + (-l);
   
4. }

复制代码

test.cpp

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

复制代码

-------------------------------------------------------------------
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-x4qpcw2n.sc2 --stdout=Microsoft-MIEngine-Out-pmiyg52x.pko --stderr=Microsoft-MIEngine-Error-ycnrwdt4.obr --pid=Microsoft-MIEngine-Pid-5gacmwbw.dbc --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi
123
654
a - b = -531
a + b = 777
==========================
999
999
a - b = 0
a + b = 1998
==========================
987654321
123456789
a - b = 864197532
a + b = 1111111110
==========================
-99
999
a - b = -1098
a + b = 900
==========================
999
-99
a - b = 1098
a + b = 900
==========================
-5555
-9999
a - b = 4444
a + b = -15554
==========================
2
0.123654
a - b = 1.876346
a + b = 2.123654
==========================
0.123456789
0.000000005
a - b = 0.123456
a + b = 0.123456
==========================
0.0006
0.0005
a - b = 0.0001
a + b = 0.0011
==========================
-0.005
0.00004
a - b = -0.00504
a + b = -0.00496
==========================
1
-0.00005
a - b = 1.00005
a + b = 0.99995
==========================
-99999
-0.0006
a - b = -99998.9994
a + b = -99999.0006
==========================
-987
987
a - b = -1974
a + b = 0
==========================

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

bin554385863

bin554385863 发表于 2020-1-5 20:25
添加减法
const lnum operator-(const lnum &l) const;

添加
+=
-=
++
--

1. //(8)+=
   
2.     const lnum &operator+=(const lnum &l);
   
3.     //(9)++
   
4.     const lnum &operator++(const int i);
   
5.     //(10)-=
   
6.     const lnum &operator-=(const lnum &l);
   
7.     //(11)--
   
8.     const lnum &operator--(const int i);

复制代码

1. //(8)+=
   
2. const lnum &lnum::operator+=(const lnum &l)
   
3. {
   
4.     return *this = *this + l;
   
5. }
   
6. //(9)++
   
7. const lnum &lnum::operator++(const int i)
   
8. {
   
9.     return *this = *this + "1";
   
10. }
    
11. //(10)-=
    
12. const lnum &lnum::operator-=(const lnum &l)
    
13. {
    
14.     return *this = *this + (-l);
    
15. }
    
16. //(11)--
    
17. const lnum &lnum::operator--(const int i)
    
18. {
    
19.     return *this = *this + "-1";
    
20. }

复制代码

bin554385863

已经实现
数字字符串加减乘三种运算和五种比较运算,

lnum.cpp

1. /*
   
2. (1)原始数字字符串->清除无效的零->转换数组,提取信息(小数位数,整数位数,是否为零);
   
3. (2)整体对齐->比较大小,设计加/减法;
   
4. (3)小数位对齐->设计数组乘整数->设计数组乘数组->实现对象乘法;
   
5. (补充)实现满十进一,退一借十;
   
6. */
   
7. #ifndef LNUM_H
   
8. #define LNUM_H
   
9. #include <iostream>
   
10. #include <string>
    
11. #include <vector>
    
12. using std::istream;
    
13. using std::ostream;
    
14. using std::string;
    
15. using std::vector;
    
16. class lnum
    
17. {
    
18.     struct ndata
    
19.     {
    
20.         int sign;
    
21.         string nstr;
    
22.         vector<int> nvec;
    
23.         size_t isize, dsize;
    
24.     };
    
25.     struct align
    
26.     {
    
27.         vector<int> first, second;
    
28.     };
    
29.    
    
30. private:
    
31.     static size_t pre;
    
32.     ndata data;
    
33.     //(0)判断是否含有小数点
    
34.     const bool hasDecPoint(const string &s) const;
    
35.     //(1)判断字符串是否有效
    
36.     const bool isInvalidStr(const string &s) const;
    
37.     //(2)判断字符串元素是否全为零
    
38.     const bool isStrElemAllZero(const string &s) const;
    
39.     //(3)清除无效的零
    
40.     const string clearInvalidZero(const string &s) const;
    
41.     //(4)转换数组
    
42.     const vector<int> strToVec(const string &s) const;
    
43.     //(-4)转换字符串
    
44.     const string vecToStr(const vector<int> &vint, int sgn, size_t dsz) const;
    
45.     //(5)提取信息
    
46.     const ndata getInfo(const string &s) const;
    
47.     //(6)小数位对齐
    
48.     align dAlign(const lnum &l) const;
    
49.     //(7)整体对齐
    
50.     align wAlign(const lnum &l) const;
    
51.     //(8)满十进一
    
52.     void carry(vector<int> &v) const;
    
53.     //(9)借一补十
    
54.     void borrow(vector<int> &v) const;
    
55.     //(10)输出设置
    
56.     const string setPrint() const;
    
57.     //(11)lnum*n
    
58.     const lnum operator*(const int &n) const;
    
59. 
    
60. public:
    
61.     lnum(const char *cstr = "0") : data(getInfo(cstr))
    
62.     {
    
63.     }
    
64.     lnum(const string &s):data(getInfo(s)){}
    
65.     void showinfo() const;
    
66.     static void setprecision(const size_t p);
    
67.     //(1)>号
    
68.     const bool operator>(const lnum &l) const;
    
69.     //(2)==
    
70.     const bool operator==(const lnum &l) const;
    
71.     //(3)>=
    
72.     const bool operator>=(const lnum &l) const;
    
73.     //(4)<
    
74.     const bool operator<(const lnum &l) const;
    
75.     //(5)<=
    
76.     const bool operator<=(const lnum &l) const;
    
77.     //(5)!=
    
78.     const bool operator!=(const lnum &l) const;
    
79.     //(6)+
    
80.     const lnum operator+(const lnum &l) const;
    
81.     //(7)-反转正负
    
82.     const lnum operator-() const;
    
83.     //(7.5)-
    
84.     const lnum operator-(const lnum &l) const;
    
85.     //(8)+=
    
86.     const lnum &operator+=(const lnum &l);
    
87.     //(9)++
    
88.     const lnum &operator++(const int i);
    
89.     //(10)-=
    
90.     const lnum &operator-=(const lnum &l);
    
91.     //(11)--
    
92.     const lnum &operator--(const int i);
    
93.     //(12)lnum*lnum
    
94.     const lnum operator*(const lnum &l) const;
    
95.     //(F)<<
    
96.     friend ostream &operator<<(ostream &os, const lnum &l);
    
97.     //(F)>>
    
98.     friend istream &operator>>(istream &is, lnum &l);
    
99. };
    
100. size_t lnum::pre = 6;
     
101. #endif

复制代码

====================================================
lnum.cpp

1. #include "E:\Users\admin\Documents\VScode\Code\My Class\lnum\lnum.h"
   
2. //(0)判断是否含有小数点
   
3. const bool lnum::hasDecPoint(const string &s) const
   
4. {
   
5.     return int(s.find('.')) > -1 ? true : false;
   
6. }
   
7. //(1)判断字符串是否有效
   
8. const bool lnum::isInvalidStr(const string &s) const
   
9. {
   
10.     bool f = true;
    
11.     string str = s;
    
12.     if (str[0] == '-')
    
13.     {
    
14.         str.erase(0, 1);
    
15.     }
    
16.     if (!hasDecPoint(str))
    
17.     {
    
18.         for (char c : str)
    
19.         {
    
20.             if (!isdigit(c))
    
21.             {
    
22.                 f = false;
    
23.                 break;
    
24.             }
    
25.         }
    
26.     }
    
27.     else
    
28.     {
    
29.         size_t dpinx = str.find('.');
    
30.         f = (dpinx == 0) || (dpinx == (str.size() - 1)) || (dpinx != str.rfind('.')) ? false : true;
    
31.         str.erase(dpinx, 1);
    
32.         for (char c : str)
    
33.         {
    
34.             if (!isdigit(c))
    
35.             {
    
36.                 f = false;
    
37.                 break;
    
38.             }
    
39.         }
    
40.     }
    
41.     return f;
    
42. }
    
43. //(2)判断字符串元素是否全为零
    
44. const bool lnum::isStrElemAllZero(const string &s) const
    
45. {
    
46.     string str = s;
    
47.     str[0] == '-' ? str.erase(0, 1) : str;
    
48.     hasDecPoint(str) || false ? str.erase(str.find('.'), 1) : str;
    
49.     return str == string(str.size(), '0') ? true : false;
    
50. }
    
51. //(3)清除无效的零
    
52. const string lnum::clearInvalidZero(const string &s) const
    
53. {
    
54.     string str = s;
    
55.     if (isInvalidStr(s))
    
56.     {
    
57.         size_t i = 0;
    
58.         if (str[0] == '-')
    
59.         {
    
60.             str.erase(0, 1);
    
61.         }
    
62.         if (!hasDecPoint(s))
    
63.         {
    
64.             size_t sz = str.size();
    
65.             while (i != sz)
    
66.             {
    
67.                 if (str[i] != '0')
    
68.                 {
    
69.                     break;
    
70.                 }
    
71.                 i++;
    
72.             }
    
73.             if (i == sz)
    
74.             {
    
75.                 str.erase(0, i - 1);
    
76.             }
    
77.             else if (i > 0)
    
78.             {
    
79.                 str.erase(0, i);
    
80.             }
    
81.         }
    
82.         else
    
83.         {
    
84.             i = 0;
    
85.             while (str[i] != '.')
    
86.             {
    
87.                 if (str[i] != '0')
    
88.                 {
    
89.                     break;
    
90.                 }
    
91.                 i++;
    
92.             }
    
93.             if (i == str.find('.'))
    
94.             {
    
95.                 str.erase(0, i - 1);
    
96.             }
    
97.             else if (i > 0)
    
98.             {
    
99.                 str.erase(0, i);
    
100.             }
     
101.             i = str.size() - 1;
     
102.             while (str[i] != '.')
     
103.             {
     
104.                 if (str[i] != '0')
     
105.                 {
     
106.                     break;
     
107.                 }
     
108.                 i--;
     
109.             }
     
110.             if (i == str.find('.'))
     
111.             {
     
112.                 str.erase(i);
     
113.             }
     
114.             else if (i < str.size() - 1)
     
115.             {
     
116.                 str.erase(i + 1);
     
117.             }
     
118.         }
     
119.     }
     
120.     if (s[0] == '-' && str != "0")
     
121.     {
     
122.         str.insert(0, 1, '-');
     
123.     }
     
124. return str;
     
125. }
     
126. //(4)转换数组
     
127. const vector<int> lnum::strToVec(const string &s) const
     
128. {
     
129.     vector<int> vint;
     
130.     string str = s;
     
131.     str[0] == '-' ? str.erase(0, 1) : str;
     
132.     hasDecPoint(str) > false ? str.erase(str.find('.'), 1) : str;
     
133.     for (char c : str)
     
134.     {
     
135.         vint.push_back(c - 48);
     
136.     }
     
137.     return vint;
     
138. }
     
139. //(-4)转换字符串
     
140. const string lnum::vecToStr(const vector<int> &vint, int sgn, size_t dsz) const
     
141. {
     
142.     string str;
     
143.     for (int i : vint)
     
144.     {
     
145.         str.push_back(i + 48);
     
146.     }
     
147.     if (str != "0")
     
148.     {
     
149.         dsz == 0 ? str : str.insert(str.size() - dsz, 1, '.');
     
150.         sgn == -1 ? str.insert(0, 1, '-') : str;
     
151.     }
     
152.     return str;
     
153. }
     
154. //(5)提取信息
     
155. const lnum::ndata lnum::getInfo(const string &s) const
     
156. {
     
157.     ndata ndt = {0, "0", {0}, 1, 0};
     
158.     if (isInvalidStr(s))
     
159.     {
     
160.         ndt.nstr = s;
     
161.         ndt.sign = ndt.nstr != "0" ? (ndt.nstr[0] == '-' ? -1 : 1) : 0;
     
162.         ndt.dsize = hasDecPoint(ndt.nstr) || false ? ndt.nstr.size() - ndt.nstr.find('.') - 1 : 0;
     
163.         ndt.nvec = strToVec(ndt.nstr);
     
164.         ndt.isize = ndt.nvec.size() - ndt.dsize;
     
165.     }
     
166.     return ndt;
     
167. }
     
168. //(6)小数位对齐
     
169. lnum::align lnum::dAlign(const lnum &l) const
     
170. {
     
171.     align agn;
     
172.     vector<int> &f = agn.first, &s = agn.second;
     
173.     f = data.nvec;
     
174.     s = l.data.nvec;
     
175.     const size_t &fds = data.dsize, &sds = l.data.dsize;
     
176.     fds > sds ? s.insert(s.end(), fds - sds, 0) : f.insert(f.end(), sds - fds, 0);
     
177.     return agn;
     
178. }
     
179. //(7)整体对齐
     
180. lnum::align lnum::wAlign(const lnum &l) const
     
181. {
     
182.     align &&agn = this->dAlign(l);
     
183.     vector<int> &f = agn.first, &s = agn.second;
     
184.     const size_t &fws = data.isize, &sws = l.data.isize;
     
185.     fws > sws ? s.insert(s.begin(), fws - sws, 0) : f.insert(f.begin(), sws - fws, 0);
     
186.     return agn;
     
187. }
     
188. //(8)满十进一
     
189. void lnum::carry(vector<int> &v) const
     
190. {
     
191.     v.insert(v.begin(), 1, 0);
     
192.     const size_t s = v.size();
     
193.     for (size_t i = s - 1; i != 0; i--)
     
194.     {
     
195.         int t = v[i];
     
196.         v[i] = t % 10;
     
197.         v[i - 1] += t / 10;
     
198.     }
     
199.     if (v[0] == 0)
     
200.     {
     
201.         v.erase(v.begin(), v.begin() + 1);
     
202.     }
     
203. }
     
204. //(9)借一补十
     
205. void lnum::borrow(vector<int> &v) const
     
206. {
     
207.     const size_t s = v.size();
     
208.     for (size_t i = 1; i < s; i++)
     
209.     {
     
210.         v[i - 1] -= 1;
     
211.         v[i] += 10;
     
212.     }
     
213. }
     
214. //(10)输出设置
     
215. const string lnum::setPrint() const
     
216. {
     
217.     const size_t &tds = data.dsize;
     
218.     string str = data.nstr;
     
219.     if (pre == 0)
     
220.     {
     
221.         if (tds != 0)
     
222.         {
     
223.             str.erase(str.find('.'));
     
224.         }
     
225.     }
     
226.     else if (tds > pre)
     
227.     {
     
228. 
     
229.         str.erase(str.size() - (tds - pre));
     
230.     }
     
231.     return clearInvalidZero(str);
     
232. }
     
233. //(11)lnum*n
     
234. const lnum lnum::operator*(const int &n) const
     
235. {
     
236.     vector<int> t = data.nvec;
     
237.     for (int &i : t)
     
238.     {
     
239.         i *= n;
     
240.     }
     
241.     carry(t);
     
242.     lnum r = vecToStr(t, data.sign, data.dsize);
     
243.     return r;
     
244. }
     
245. //==========================================================================
     
246. //(0)显示信息
     
247. void lnum::showinfo() const
     
248. {
     
249.     std::cout << "正/负/零: " << data.sign << "\n"
     
250.               << "原始数字: " << data.nstr << "\n"
     
251.               << "数组元素: ";
     
252.     for (int i : data.nvec)
     
253.     {
     
254.         std::cout << i << " ";
     
255.     }
     
256.     std::cout << std::endl;
     
257.     std::cout << "整数位数: " << data.isize << "\n"
     
258.               << "小数位数: " << data.dsize << std::endl;
     
259. }
     
260. void lnum::setprecision(const size_t p)
     
261. {
     
262.     pre = p;
     
263. }
     
264. //(1)>号
     
265. const bool lnum::operator>(const lnum &l) const
     
266. {
     
267.     bool f = true;
     
268.     const int &tsgn = data.sign, &lsgn = l.data.sign;
     
269.     if (tsgn < lsgn)
     
270.     {
     
271.         f = false;
     
272.     }
     
273.     else if (tsgn == lsgn)
     
274.     {
     
275.         const align &agn = this->wAlign(l);
     
276.         f = agn.first > agn.second;
     
277.         if (tsgn == -1)
     
278.         {
     
279.             f = !f;
     
280.         }
     
281.     }
     
282.     return f;
     
283. }
     
284. //(2)==
     
285. const bool lnum::operator==(const lnum &l) const
     
286. {
     
287.     return (data.sign == l.data.sign) && (data.nvec == l.data.nvec);
     
288. }
     
289. //(3)>=
     
290. const bool lnum::operator>=(const lnum &l) const
     
291. {
     
292.     return (*this > l) || (*this == l);
     
293. }
     
294. //(4)<
     
295. const bool lnum::operator<(const lnum &l) const
     
296. {
     
297.     return !(*this >= l);
     
298. }
     
299. //(5)<=
     
300. const bool lnum::operator<=(const lnum &l) const
     
301. {
     
302.     return (*this < l) || (*this == l);
     
303. }
     
304. //(5.5)!=
     
305. const bool lnum::operator!=(const lnum &l) const
     
306. {
     
307.     return !(*this == l);
     
308. }
     
309. //(6)+
     
310. const lnum lnum::operator+(const lnum &l) const
     
311. {
     
312.     lnum r;
     
313.     if (*this != (-l))
     
314.     {
     
315.         align agn = this->wAlign(l);
     
316.         vector<int> &fst = agn.first,
     
317.                     &sec = agn.second,
     
318.                     &greater = fst >= sec ? fst : sec,
     
319.                     &less = sec <= fst ? sec : fst;
     
320.         const int &tsgn = data.sign,
     
321.                   &lsgn = l.data.sign;
     
322.         const size_t &sz = fst.size();
     
323.         for (size_t i = 0; i < sz; i++)
     
324.         {
     
325.             greater[i] += (lsgn * tsgn) * less[i];
     
326.         }
     
327.         int sgn = 1;
     
328.         if (tsgn == lsgn)
     
329.         {
     
330.             sgn = tsgn;
     
331.         }
     
332.         else if (tsgn != lsgn)
     
333.         {
     
334.             sgn = ((greater == fst && tsgn < lsgn) || (less == fst && tsgn > lsgn)) || false ? -1 : sgn;
     
335.         }
     
336.         if (tsgn * lsgn == -1)
     
337.         {
     
338.             borrow(greater);
     
339.         }
     
340.         carry(greater);
     
341.         size_t dsz = data.dsize >= l.data.dsize ? data.dsize : l.data.dsize;
     
342.         //string str = vecToStr(greater, sgn, dsz);
     
343.         r = vecToStr(greater, sgn, dsz);
     
344.     }
     
345.     return r;
     
346. }
     
347. 
     
348. //(7)-反转正负
     
349. const lnum lnum::operator-() const
     
350. {
     
351.     lnum r = *this;
     
352.     if (data.sign != 0)
     
353.     {
     
354.         r.data.sign = -data.sign;
     
355.         r.data.nstr = vecToStr(data.nvec, -data.sign, data.dsize);
     
356.     }
     
357.     return r;
     
358. }
     
359. //(7.5)-
     
360. const lnum lnum::operator-(const lnum &l) const
     
361. {
     
362.     return *this + (-l);
     
363. }
     
364. //(8)+=
     
365. const lnum &lnum::operator+=(const lnum &l)
     
366. {
     
367.     return *this = *this + l;
     
368. }
     
369. //(9)++
     
370. const lnum &lnum::operator++(const int i)
     
371. {
     
372.     return *this = *this + "1";
     
373. }
     
374. //(10)-=
     
375. const lnum &lnum::operator-=(const lnum &l)
     
376. {
     
377.     return *this = *this + (-l);
     
378. }
     
379. //(11)--
     
380. const lnum &lnum::operator--(const int i)
     
381. {
     
382.     return *this = *this + "-1";
     
383. }
     
384. //(12)lnum*lnum
     
385. const lnum lnum::operator*(const lnum &l) const
     
386. {
     
387.     lnum r;
     
388.     const int &tsgn = data.sign,
     
389.               &lsgn = l.data.sign;
     
390.     if (tsgn * lsgn == 0)
     
391.     {
     
392.         r = "0";
     
393.     }
     
394.     else
     
395.     {
     
396.         const vector<int> &tvec = data.nvec,
     
397.                           &lvec = l.data.nvec;
     
398.         const size_t &tsz = data.dsize,
     
399.                      &lsz = l.data.dsize,
     
400.                      &tvsz = tvec.size(),
     
401.                      &lvsz = lvec.size(),
     
402.                      &shrtsz = tvsz <= lvsz ? tvsz : lvsz;
     
403.         lnum loong = tvsz >= lvsz ? *this : l;
     
404.         const vector<int> &shrtv = lvsz <= tvsz ? lvec : tvec;
     
405.         vector<int> &lovec = loong.data.nvec,
     
406.                     &rvec = r.data.nvec;
     
407.         for (size_t i = shrtsz - 1; i != -1; i--)
     
408.         {
     
409.             r += loong * shrtv[i];
     
410.             if (i > 0)
     
411.             {
     
412.                 lovec.push_back(0);
     
413.             }
     
414.         }
     
415.         r = vecToStr(rvec, tsgn * lsgn, tsz + lsz);
     
416.     }
     
417.     return r;
     
418. }
     
419. //(F)<<
     
420. ostream &operator<<(ostream &os, const lnum &l)
     
421. {
     
422.     os << l.setPrint();
     
423.     return os;
     
424. }
     
425. //(F)>>
     
426. istream &operator>>(istream &is, lnum &l)
     
427. {
     
428.     string str;
     
429.     (std::cin >> str).get();
     
430.     l = str;
     
431.     return is;
     
432. }

复制代码

===========================================