C++课程设计之大整数类

点击打开链接

偶然间发现去年写的课程设计作业，写的还不错，涉及的知识面还挺多的，现在都有些记不得了，有时间得好好看看c++了。

题目: 设计并实现大整数类，并测试其加减乘除运算（至少有一个数是20位以上的整数）。利用它计算并显示30！。(要求：必须实现拷贝构造函数、四则运算重载、友元函数、插入和提取运算符重载)

 

问题分析：

    要想实现真正的大整数类，即其位数不确定且可以无限大，那么选择容器是最佳的，用数组的话必须确定其大小，那么这个所谓的大整数的位数就有了上限，所以这里我选择用vector，并使用string类对其进行输入输出操作，代码如下。实现了拷贝构造函数、四则运算重载、友元函数、插入和提取运算符重载。四则运算对于负数也是适用的，除法只考虑求商。

代码实现：（运行环境为Microsoft Visual Studio 2010）

[cpp]  view plain  copy

 

1. #include<iostream>  
2. #include<vector>  
3. #include<string>  
4. #include<cstring>  
5. using namespace std;  
6. class BigInt  
7. {  
8. public:  
9.     BigInt();  
10.     BigInt(long int s);  
11.     BigInt(string str);  
12.     BigInt(BigInt& a);  
13.     friend BigInt operator+(BigInt a,BigInt b);  
14.     friend BigInt operator-(BigInt a,BigInt b);  
15.     friend BigInt operator*(BigInt a,BigInt b);  
16.     friend BigInt operator/(BigInt a,BigInt b);//除法算法不太好  
17.     friend ostream& operator<<(ostream& out,BigInt& a);  
18.     friend istream& operator>>(istream& in,BigInt& a);  
19.     BigInt operator=(BigInt a);  
20.     friend int SizeJudge(BigInt a,BigInt b);  
21.     vector<int> vec;  
22.     int negative;//0为正，1为负  
23. };  
24. BigInt::BigInt()  
25. {  
26.     vec.push_back(0);  
27.     negative = 0;  
28. }  
29. BigInt::BigInt(long int s)  
30. {  
31.     if(s<0)  
32.     {  
33.         negative = 1;  
34.         s = -s;  
35.     }  
36.     else  
37.         negative = 0;  
38.     int i;  
39.     while(s>9)  
40.     {  
41.         i = s%10;  
42.         vec.push_back(i);  
43.         s /=10;  
44.     }  
45.     vec.push_back(s);  
46. }  
47. BigInt::BigInt(string str)  
48. {  
49.     if(str[0] == '-')  
50.     {  
51.         negative = 1;  
52.         str = str.substr(1,str.size()-1);  
53.     }  
54.     else  
55.         negative = 0;  
56.     for(int i=str.size()-1;i>=0;i--)  
57.     {  
58.         vec.push_back(str[i]-'0');  
59.     }  
60. }  
61. BigInt::BigInt(BigInt& a)  
62. {  
63.     vec = a.vec;  
64.     negative = a.negative;  
65. }  
66. BigInt BigInt::operator=(BigInt a)  
67. {  
68.     vec = a.vec;  
69.     negative = a.negative;  
70.     return *this;  
71. }  
72. ostream& operator<<(ostream& out,BigInt& a)  
73. {  
74.     string str="";  
75.     int judge = 0;  
76.     if((a.vec[a.vec.size()-1]+'0') == '-')  
77.         judge = 1;  
78.     if((a.negative == 1)&&judge == 0)  
79.     {  
80.         str += '-';  
81.     }  
82.     for(int i=a.vec.size()-1;i>=0;i--)  
83.     {  
84.         str += (a.vec[i]+'0');  
85.     }  
86.     out<<str;  
87.     return out;  
88. }  
89. istream& operator>>(istream& in,BigInt& a)  
90. {  
91.     string str="";  
92.     in>>str;  
93.     a.vec.clear();  
94.     for(int i=str.size()-1;i>=0;i--)  
95.     {  
96.         a.vec.push_back(str[i]-'0');  
97.     }  
98.     return in;  
99. }  
100. BigInt operator+(BigInt a,BigInt b)  
101. {  
102.     int negative_judge = 0;  
103.     if(a.negative == 1&&b.negative == 1)//全负  
104.     {  
105.         negative_judge = 1;  
106.     }  
107.     if(a.negative == 0&&b.negative == 0)//全正  
108.     {  
109.         negative_judge = 0;  
110.     }  
111.     if(a.negative == 0&&b.negative == 1)//a正b负  
112.     {  
113.         b.negative = 0;  
114.         return (a-b);  
115.     }  
116.     if(a.negative == 1&&b.negative == 0)//a负b正  
117.     {  
118.         a.negative = 0;  
119.         return (b-a);  
120.     }  
121.     BigInt c,tmp;  
122.     int alen,blen,min,max,i;  
123.     alen = a.vec.size();  
124.     blen = b.vec.size();  
125.     if(alen>blen)  
126.     {  
127.         c.vec = a.vec;  
128.         tmp.vec = b.vec;  
129.         min = blen;  
130.         max = alen;  
131.     }  
132.     else  
133.     {  
134.         c.vec = b.vec;  
135.         tmp.vec = a.vec;  
136.         min = alen;  
137.         max = blen;  
138.     }  
139.     for(i=0;i<min-1;i++)//min=max？  
140.     {  
141.         c.vec[i] += tmp.vec[i];  
142.         if(c.vec[i]>9)  
143.         {  
144.             c.vec[i] -= 10;  
145.             c.vec[i+1] += 1;  
146.         }  
147.     }  
148.     c.vec[i] +=tmp.vec[i];  
149.     if(c.vec[i]>9)  
150.     {  
151.         c.vec[i] -=10;  
152.         if(min == max)  
153.             c.vec.push_back(1);  
154.         else  
155.             c.vec[i+1] +=1;  
156.     }  
157.     for(i=min;i<max-1;i++)  
158.     {  
159.         if(c.vec[i]>9)  
160.         {  
161.             c.vec[i] -=10;  
162.             c.vec[i+1] +=1;  
163.         }  
164.     }  
165.     if(c.vec[max-1]>9)  
166.     {  
167.         c.vec[max-1] -=10;  
168.         c.vec.push_back(1);  
169.     }  
170.     i=c.vec.size()-1;//去掉前面的0  
171.     while(c.vec[i] == 0)  
172.     {  
173.         c.vec.pop_back();  
174.         i--;  
175.     }  
176.     if(negative_judge == 1)  
177.     {  
178.         string str = "-";  
179.         c.vec.push_back(str[0]-'0');  
180.     }  
181.     return c;  
182. }  
183. BigInt operator-(BigInt a,BigInt b)  
184. {  
185.     int negative_judge = 0;  
186.     if(a.negative == 1&&b.negative == 1)//全负  
187.     {  
188.         a.negative = 0;  
189.         b.negative = 0;  
190.         return (b-a);  
191.     }  
192.     if(a.negative == 0&&b.negative == 0)//全正  
193.     {  
194.         negative_judge = 0;  
195.     }  
196.     if(a.negative == 0&&b.negative == 1)//a正b负  
197.     {  
198.         b.negative = 0;  
199.         return (a+b);  
200.     }  
201.     if(a.negative == 1&&b.negative == 0)//a负b正  
202.     {  
203.         b.negative =1;  
204.         return (a+b);  
205.     }  
206.     BigInt c,tmp;  
207.     int alen,blen,min,max,i,judge=0;  
208.     alen = a.vec.size();  
209.     blen = b.vec.size();  
210.     //大值赋给c，小值赋给tmp  
211.     if(alen>blen)  
212.     {  
213.         c.vec = a.vec;  
214.         tmp.vec = b.vec;  
215.         min = blen;  
216.         max = alen;  
217.         judge = 1;  
218.     }  
219.     else if(alen == blen)  
220.     {  
221.         for(i=alen-1;i>=0;i--)  
222.         {  
223.             if(a.vec[i]>b.vec[i])  
224.             {  
225.                 c.vec = a.vec;  
226.                 tmp.vec = b.vec;  
227.                 min = blen;  
228.                 max = alen;  
229.                 judge = 1;  
230.                 break;  
231.             }  
232.             else if(a.vec[i]<b.vec[i])  
233.             {  
234.                 c.vec = b.vec;  
235.                 tmp.vec = a.vec;  
236.                 min = alen;  
237.                 max = blen;  
238.                 judge = 2;  
239.                 break;  
240.             }  
241.         }  
242.         if(i==-1)  
243.             return (BigInt)0;  
244.     }  
245.     else  
246.     {  
247.         c.vec = b.vec;  
248.         tmp.vec = a.vec;  
249.         min = alen;  
250.         max = blen;  
251.         judge = 2;  
252.     }  
253.     for(i=0;i<min;i++)//min=max？c>tmp  
254.     {  
255.         c.vec[i] -= tmp.vec[i];  
256.         if(c.vec[i]<0)  
257.         {  
258.             c.vec[i] += 10;  
259.             c.vec[i+1] -= 1;  
260.         }  
261.     }  
262.     if(min<max)  
263.         for(i=min;i<max;i++)  
264.         {  
265.             if(c.vec[i]<0)  
266.             {  
267.                 c.vec[i] +=10;  
268.                 c.vec[i+1] -=1;  
269.             }  
270.         }  
271.         if(judge == 2)  
272.         {  
273.             string str="-";  
274.             c.vec.push_back(str[0]-'0');  
275.         }  
276.         i=c.vec.size()-1;//去掉前面的0  
277.         while(c.vec[i] == 0)  
278.         {  
279.             c.vec.pop_back();  
280.             i--;  
281.         }  
282.         return c;  
283. }  
284. BigInt operator*(BigInt a,BigInt b)  
285. {  
286.     BigInt c;  
287.     int alen,blen,i,j,max,tmp;  
288.     alen = a.vec.size();  
289.     blen = b.vec.size();  
290.     max = alen+blen;  
291.     c.vec.clear();  
292.     for(i=0;i<max;i++)  
293.     {  
294.         c.vec.push_back(0);  
295.     }  
296.     for(i=0;i<alen;i++)  
297.     {  
298.         for(j=0;j<blen;j++)  
299.         {  
300.             tmp = c.vec[i+j]+a.vec[i]*b.vec[j];  
301.             if(tmp>9)  
302.             {  
303.                 if(i+j+1<max)  
304.                 {  
305.                     c.vec[i+j+1] += tmp/10;  
306.                     tmp %= 10;  
307.                 }  
308.                 else  
309.                 {  
310.                     c.vec.push_back(tmp/10);  
311.                     tmp %= 10;  
312.                 }  
313.             }  
314.             c.vec[i+j] = tmp;  
315.         }  
316.     }  
317.     i=c.vec.size()-1;//去掉前面的0  
318.     while(c.vec[i] == 0)  
319.     {  
320.         c.vec.pop_back();  
321.         i--;  
322.     }  
323.     if((a.negative == 0&&b.negative == 1)||(a.negative ==    
324. 1&&b.negative == 0))//a正b负//a负b正  
325.     {  
326.         string str="-";  
327.         c.vec.push_back(str[0]-'0');  
328.         c.negative = 1;  
329.     }  
330.     else  
331.     {  
332.         c.negative = 0;  
333.     }  
334.     return c;  
335. }  
336. BigInt operator/(BigInt a,BigInt b)  
337. {  
338.     if(SizeJudge(a,b) == -1)  
339.     {  
340.         return (BigInt)0;  
341.     }  
342.     else if(SizeJudge(a,b) == 0)  
343.     {  
344.         return (BigInt)1;  
345.     }  
346.     BigInt tmp;  
347.     int alen,blen,i;  
348.     alen = a.vec.size();  
349.     blen = b.vec.size();  
350.     if(blen == 1&&b.vec[0] == 0)  
351.     {  
352.         BigInt err("error");  
353.         return err;  
354.     }  
355.     i = alen-blen;  
356.     int j = 1;  
357.     while(i>0)  
358.     {  
359.         j *=10;  
360.         i--;  
361.     }  
362.     BigInt count(j);  
363.     tmp = count*b;  
364.     if(SizeJudge(a,tmp) == 1)  
365.     {  
366.         while(SizeJudge(a,tmp) == 1)  
367.         {  
368.             count = count+1;  
369.             tmp = b*count;  
370.         }  
371.     }  
372.     else if(SizeJudge(a,tmp) == -1)  
373.     {  
374.         while(SizeJudge(a,tmp) == -1)  
375.         {  
376.             count = count-1;  
377.             tmp = b*count;  
378.         }  
379.     }  
380.     if((a.negative == 0&&b.negative == 1)||(a.negative ==    
381. 1&&b.negative == 0))//a正b负//a负b正  
382.     {  
383.         string str="-";  
384.         count.vec.push_back(str[0]-'0');  
385.         count.negative = 1;  
386.     }  
387.     else  
388.     {  
389.         count.negative = 0;  
390.     }  
391.     return count;  
392. }  
393. int SizeJudge(BigInt a,BigInt b)  
394. {//1代表大于，0代表等于，-1代表小于  
395.     int alen,blen,i;  
396.     alen = a.vec.size();  
397.     blen = b.vec.size();  
398.     if(alen>blen)  
399.     {  
400.         return 1;  
401.     }  
402.     else if(alen == blen)  
403.     {  
404.         for(i=alen-1;i>=0;i--)  
405.         {  
406.             if(a.vec[i]>b.vec[i])  
407.             {  
408.                 return 1;  
409.             }  
410.             else if(a.vec[i]<b.vec[i])  
411.             {  
412.                 return -1;  
413.             }  
414.         }  
415.         if(i==0)  
416.             return 0;  
417.     }  
418.     else  
419.     {  
420.         return -1;  
421.     }  
422. }  
423. int main()  
424. {  
425.     测试数据输入  
426.     //BigInt a("999999999999999999999"),b("8888"),c;  
427.     //cin>>b;  
428.     //cout<<"the input:"<<b<<endl;  
429.     //c = a+b;  
430.     //cout<<a<<"+"<<b<<"="<<c<<endl;  
431.     //cin.get();  
432.     测试加法  
433.     //BigInt a("999999999999999999999"),b("8888"),c;  
434.     //c = a+b;  
435.     //cout<<a<<"+"<<b<<"="<<c<<endl;  
436.     //BigInt d("-1111");  
437.     //c = a+d;  
438.     //cout<<a<<"+"<<d<<"="<<c<<endl;  
439.     //c = 7777777+a;  
440.     //cout<<"7777777"<<"+"<<a<<"="<<c<<endl;  
441.     //BigInt s(a);//调用拷贝构造函数  
442.     //c = s+a;  
443.     //cout<<s<<"+"<<a<<"="<<c<<endl;  
444.     测试减法  
445.     //BigInt a("999999999999999999999"),b("8888"),c;  
446.     //c = a-b;  
447.     //cout<<a<<"-"<<b<<"="<<c<<endl;  
448.     //BigInt d("-1111");  
449.     //c = a-d;  
450.     //cout<<a<<"-"<<d<<"="<<c<<endl;  
451.     //c = 7777777-a;  
452.     //cout<<"7777777"<<"-"<<a<<"="<<c<<endl;  
453.     测试乘法  
454.     //BigInt a("999999999999999999999"),b("8888"),c;  
455.     //c = a*b;  
456.     //cout<<a<<"*"<<b<<"="<<c<<endl;  
457.     //BigInt d("-1111");  
458.     //c = a*d;  
459.     //cout<<a<<"*"<<d<<"="<<c<<endl;  
460.     //c = 7777777*a;  
461.     //cout<<"7777777"<<"*"<<a<<"="<<c<<endl;  
462.     ///测试除法  
463.     //BigInt a("999999999999999999999"),b("888888888888888"),c;  
464.     //c = a/b;  
465.     //cout<<a<<"/"<<b<<"="<<c<<endl;  
466.     //c = b/a;  
467.     //cout<<b<<"/"<<a<<"="<<c<<endl;  
468.     //BigInt d("-111111111111111");  
469.     //c = a/d;  
470.     //cout<<a<<"/"<<d<<"="<<c<<endl;  
471.     //c = 0/a;  
472.     //cout<<"0"<<"/"<<a<<"="<<c<<endl;  
473.    //计算并显示30！  
474.     BigInt a("30"),c("1");  
475.     int i = 30;  
476.     while(i>0)  
477.     {  
478.         c = c*a;  
479.         a = a-1;  
480.         i--;  
481.     }  
482.     cout<<"30! = "<<c<<endl;  
483.     return 0;  
484. }  

运行结果：

1．输入：

 

2. 加法：（包含调用拷贝构造函数）

3. 减法：

 

4. 乘法：

 

5. 除法：(求商)

 

6. 计算并显示30！