C++ BigInteger模板

1 #include <cstdio>
2 #include <cstring>
3 #include <string>
4 #include <iostream>
5 #include <iomanip>
6 #include <algorithm>
7 using namespace std;
8
9 #define MAXN 9999
10 #define MAXSIZE 10
11 #define DLEN 4
12 const long long MOD = 258280327;
13 class BigInteger
14 {
15 private:
16     int a[3000];    //可以控制大数的位数
17     int len;       //大数长度
18 public:
19     BigInteger(){ len = 1; memset(a, 0, sizeof(a)); }   //构造函数
20     BigInteger(const int);       //将一个int类型的变量转化为大数
21     BigInteger(const char*);     //将一个字符串类型的变量转化为大数
22     BigInteger(const BigInteger &);  //拷贝构造函数
23     BigInteger &operator=(const BigInteger &);   //重载赋值运算符，大数之间进行赋值运算
24
25     friend istream& operator>>(istream&, BigInteger&);   //重载输入运算符
26     friend ostream& operator<<(ostream&, BigInteger&);   //重载输出运算符
27
28     BigInteger operator+(const BigInteger &) const;   //重载加法运算符，两个大数之间的相加运算
29     BigInteger operator-(const BigInteger &) const;   //重载减法运算符，两个大数之间的相减运算
30     BigInteger operator*(const BigInteger &) const;   //重载乘法运算符，两个大数之间的相乘运算
31     BigInteger operator/(const int   &) const;    //重载除法运算符，大数对一个整数进行相除运算
32
33     BigInteger operator^(const int  &) const;    //大数的n次方运算
34     long long    operator%(const long long  &) const;    //大数对一个int类型的变量进行取模运算
35     bool   operator>(const BigInteger & T)const;   //大数和另一个大数的大小比较
36     bool   operator>(const int & t)const;      //大数和一个int类型的变量的大小比较
37
38     void print();       //输出大数
39 };
40 BigInteger::BigInteger(const int b)     //将一个int类型的变量转化为大数
41 {
42     int c, d = b;
43     len = 0;
44     memset(a, 0, sizeof(a));
45     while (d > MAXN)
46     {
47         c = d - (d / (MAXN + 1)) * (MAXN + 1);
48         d = d / (MAXN + 1);
49         a[len++] = c;
50     }
51     a[len++] = d;
52 }
53 BigInteger::BigInteger(const char*s)     //将一个字符串类型的变量转化为大数
54 {
55     int t, k, index, l, i;
56     memset(a, 0, sizeof(a));
57     l = strlen(s);
58     len = l / DLEN;
59     if (l%DLEN)
60         len++;
61     index = 0;
62     for (i = l - 1; i >= 0; i -= DLEN)
63     {
64         t = 0;
65         k = i - DLEN + 1;
66         if (k<0)
67             k = 0;
68         for (int j = k; j <= i; j++)
69             t = t * 10 + s[j] - '0';
70         a[index++] = t;
71     }
72 }
73 BigInteger::BigInteger(const BigInteger & T) : len(T.len)  //拷贝构造函数
74 {
75     int i;
76     memset(a, 0, sizeof(a));
77     for (i = 0; i < len; i++)
78         a[i] = T.a[i];
79 }
80 BigInteger & BigInteger::operator=(const BigInteger & n)   //重载赋值运算符，大数之间进行赋值运算
81 {
82     int i;
83     len = n.len;
84     memset(a, 0, sizeof(a));
85     for (i = 0; i < len; i++)
86         a[i] = n.a[i];
87     return *this;
88 }
89 istream& operator>>(istream & in, BigInteger & b)   //重载输入运算符
90 {
91     char ch[MAXSIZE * 4];
92     int i = -1;
93     in >> ch;
94     int l = strlen(ch);
95     int count = 0, sum = 0;
96     for (i = l - 1; i >= 0;)
97     {
98         sum = 0;
99         int t = 1;
100         for (int j = 0; j<4 && i >= 0; j++, i--, t *= 10)
101         {
102             sum += (ch[i] - '0')*t;
103         }
104         b.a[count] = sum;
105         count++;
106     }
107     b.len = count++;
108     return in;
109
110 }
111 ostream& operator<<(ostream& out, BigInteger& b)   //重载输出运算符
112 {
113     int i;
114     cout << b.a[b.len - 1];
115     for (i = b.len - 2; i >= 0; i--)
116     {
117         cout.width(DLEN);
118         cout.fill('0');
119         cout << b.a[i];
120     }
121     return out;
122 }
123
124 BigInteger BigInteger::operator+(const BigInteger & T) const   //两个大数之间的相加运算
125 {
126     BigInteger t(*this);
127     int i, big;      //位数
128     big = T.len > len ? T.len : len;
129     for (i = 0; i < big; i++)
130     {
131         t.a[i] += T.a[i];
132         if (t.a[i] > MAXN)
133         {
134             t.a[i + 1]++;
135             t.a[i] -= MAXN + 1;
136         }
137     }
138     if (t.a[big] != 0)
139         t.len = big + 1;
140     else
141         t.len = big;
142     return t;
143 }
144 BigInteger BigInteger::operator-(const BigInteger & T) const   //两个大数之间的相减运算
145 {
146     int i, j, big;
147     bool flag;
148     BigInteger t1, t2;
149     if (*this>T)
150     {
151         t1 = *this;
152         t2 = T;
153         flag = 0;
154     }
155     else
156     {
157         t1 = T;
158         t2 = *this;
159         flag = 1;
160     }
161     big = t1.len;
162     for (i = 0; i < big; i++)
163     {
164         if (t1.a[i] < t2.a[i])
165         {
166             j = i + 1;
167             while (t1.a[j] == 0)
168                 j++;
169             t1.a[j--]--;
170             while (j > i)
171                 t1.a[j--] += MAXN;
172             t1.a[i] += MAXN + 1 - t2.a[i];
173         }
174         else
175             t1.a[i] -= t2.a[i];
176     }
177     t1.len = big;
178     while (t1.a[t1.len - 1] == 0 && t1.len > 1)
179     {
180         t1.len--;
181         big--;
182     }
183     if (flag)
184         t1.a[big - 1] = 0 - t1.a[big - 1];
185     return t1;
186 }
187
188 BigInteger BigInteger::operator*(const BigInteger & T) const   //两个大数之间的相乘运算
189 {
190     BigInteger ret;
191     int i, j, up;
192     int temp, temp1;
193     for (i = 0; i < len; i++)
194     {
195         up = 0;
196         for (j = 0; j < T.len; j++)
197         {
198             temp = a[i] * T.a[j] + ret.a[i + j] + up;
199             if (temp > MAXN)
200             {
201                 temp1 = temp - temp / (MAXN + 1) * (MAXN + 1);
202                 up = temp / (MAXN + 1);
203                 ret.a[i + j] = temp1;
204             }
205             else
206             {
207                 up = 0;
208                 ret.a[i + j] = temp;
209             }
210         }
211         if (up != 0)
212             ret.a[i + j] = up;
213     }
214     ret.len = i + j;
215     while (ret.a[ret.len - 1] == 0 && ret.len > 1)
216         ret.len--;
217     return ret;
218 }
219 BigInteger BigInteger::operator/(const int & b) const   //大数对一个整数进行相除运算
220 {
221     BigInteger ret;
222     int i, down = 0;
223     for (i = len - 1; i >= 0; i--)
224     {
225         ret.a[i] = (a[i] + down * (MAXN + 1)) / b;
226         down = a[i] + down * (MAXN + 1) - ret.a[i] * b;
227     }
228     ret.len = len;
229     while (ret.a[ret.len - 1] == 0 && ret.len > 1)
230         ret.len--;
231     return ret;
232 }
233 long long BigInteger::operator %(const long long & b) const    //大数对一个int类型的变量进行取模运算
234 {
235     int i;
236     long long d = 0;
237     for (i = len - 1; i >= 0; i--)
238     {
239         d = ((d * (MAXN + 1)) % b + (long long)(a[i])) % b;
240     }
241     return d;
242 }
243 BigInteger BigInteger::operator^(const int & n) const    //大数的n次方运算
244 {
245     BigInteger t, ret(1);
246     int i;
247     if (n<0)
248         exit(-1);
249     if (n == 0)
250         return 1;
251     if (n == 1)
252         return *this;
253     int m = n;
254     while (m>1)
255     {
256         t = *this;
257         for (i = 1; i << 1 <= m; i <<= 1)
258         {
259             t = t*t;
260         }
261         m -= i;
262         ret = ret*t;
263         if (m == 1)
264             ret = ret*(*this);
265     }
266     return ret;
267 }
268 bool BigInteger::operator>(const BigInteger & T) const   //大数和另一个大数的大小比较
269 {
270     int ln;
271     if (len > T.len)
272         return true;
273     else if (len == T.len)
274     {
275         ln = len - 1;
276         while (a[ln] == T.a[ln] && ln >= 0)
277             ln--;
278         if (ln >= 0 && a[ln] > T.a[ln])
279             return true;
280         else
281             return false;
282     }
283     else
284         return false;
285 }
286 bool BigInteger::operator >(const int & t) const    //大数和一个int类型的变量的大小比较
287 {
288     BigInteger b(t);
289     return *this>b;
290 }
291
292 void BigInteger::print()    //输出大数
293 {
294     int i;
295     cout << a[len - 1];
296     for (i = len - 2; i >= 0; i--)
297     {
298         cout.width(DLEN);
299         cout.fill('0');
300         cout << a[i];
301     }
302     cout << endl;
303 }