一个十进制大数运算类，支持加减乘除模、n次乘方、n次开方等运算

yuxh

花了点时间写了这么个东西，目前只支持正整数的运算。
还有很多重要的功能，如素性的检测等还没有完成。
增加了负数 --20060823

decnum.h

1. #include <stdio.h>
   
2. #include <math.h>
   
3. #include <iostream>
   
4. 
   
5. using namespace std;
   
6. 
   
7. class decnum
   
8. {
   
9.     friend decnum pow(const decnum& x, int n);
   
10.     friend decnum root(const decnum& x, int n);
    
11.     friend decnum div(const decnum& x, const decnum& y, decnum& r);
    
12.     friend decnum abs(const decnum& x);
    
13.     friend bool operator==(const decnum& x, const decnum&y);
    
14.     friend bool operator!=(const decnum& x, const decnum&y);
    
15.     friend bool operator>(const decnum& x, const decnum&y);
    
16.     friend bool operator<(const decnum& x, const decnum&y);
    
17.     friend bool operator>=(const decnum& x, const decnum&y);
    
18.     friend bool operator<=(const decnum& x, const decnum&y);
    
19.     friend ostream& operator<<(ostream&os, const decnum& x);
    
20. 
    
21. public:
    
22.     decnum() : cap(0), num(0), sign(0), val(NULL) { }
    
23.     decnum(const char *v, int n)
    
24.     {
    
25.         int i, j;
    
26.         val = new char[n];
    
27.         if(v[0] == '-') {
    
28.             sign = 1;
    
29.             v++;
    
30.             n--;
    
31.         }
    
32.         else {
    
33.             sign = 0;
    
34.             if(v[0] == '+')
    
35.                 v++;
    
36.         }
    
37.         for(i = 0; i < n && v[i] == '0'; i++);
    
38.         for(j=0; i<n; i++, j++)
    
39.             if(v[n-1-i] >= '0' && v[n-1-i] <= '9')
    
40.                 val[j] = v[n-1-i] - '0';
    
41.             else
    
42.                 break;
    
43.         num = j;
    
44.         cap = n;
    
45.     }
    
46.     decnum(const decnum& x)
    
47.     {
    
48.         val = new char[x.num];
    
49.         memcpy(val, x.val, x.num);
    
50.         sign = x.sign;
    
51.         num = x.num;
    
52.         cap = x.num;
    
53.     }
    
54.     decnum(int x)
    
55.     {
    
56.         if(x==0) {
    
57.             cap = num = 0;
    
58.             val = NULL;
    
59.             return;
    
60.         }
    
61.         if(x < 0) {
    
62.             sign = 1;
    
63.             x = -x;
    
64.         }
    
65.         else
    
66.             sign = 0;
    
67.         char temp[20];
    
68.         sprintf(temp, "%d", x);
    
69.         int n = strlen(temp);
    
70.         num = cap = n;
    
71.         val = new char[n];
    
72.         for(int i=0; i<n; i++)
    
73.             val[i] = temp[n-1-i] - '0';
    
74.     }
    
75.     decnum(long long x)
    
76.     {
    
77.         if(x==0) {
    
78.             cap = num = 0;
    
79.             val = NULL;
    
80.             return;
    
81.         }
    
82.         if(x < 0) {
    
83.             sign = 1;
    
84.             x = -x;
    
85.         }
    
86.         else
    
87.             sign = 0;
    
88.         char temp[20];
    
89.         sprintf(temp, "%lld", x);
    
90.         int n = strlen(temp);
    
91.         num = cap = n;
    
92.         val = new char[n];
    
93.         for(int i=0; i<n; i++)
    
94.             val[i] = temp[n-1-i] - '0';
    
95.     }
    
96.     ~decnum() { delete[] val; }
    
97. 
    
98.     int size() const { return num; }
    
99. 
    
100.     decnum&
     
101.     operator=(const decnum& x)
     
102.     {
     
103.         if (this != &x) {
     
104.             if(cap < x.num) {
     
105.                 delete[] val;
     
106.                 val = new char[x.num];
     
107.                 cap = x.num;
     
108.             }
     
109.             memcpy(val, x.val, x.num);
     
110.             num = x.num;
     
111.             sign = x.sign;
     
112.         }
     
113.         return *this;
     
114.     }
     
115.     decnum&
     
116.     operator=(int x)
     
117.     {
     
118.         *this = decnum(x);
     
119.         return *this;
     
120.     }
     
121.     decnum&
     
122.     operator=(long long x)
     
123.     {
     
124.         *this = decnum(x);
     
125.         return *this;
     
126.     }
     
127. 
     
128.     decnum& abs()
     
129.     {
     
130.         sign = 0;
     
131.         return *this;
     
132.     }
     
133.     decnum& operator+=(const decnum& x);
     
134.     decnum& operator-=(const decnum& x);
     
135.     decnum& operator*=(const decnum& x);
     
136.     decnum& operator/=(const decnum& x);
     
137.     decnum& operator%=(const decnum& x);
     
138.     decnum  operator+(const decnum& x) const;
     
139.     decnum  operator-(const decnum& x) const;
     
140.     decnum  operator*(const decnum& x) const;
     
141.     decnum  operator/(const decnum& x) const;
     
142.     decnum  operator%(const decnum& x) const;
     
143. 
     
144.     bool ispow(int n, decnum& r) const;
     
145.     bool ispow() const;
     
146. private:
     
147.     int  cap;
     
148.     int  num;
     
149.     int  sign;
     
150.     char *val;
     
151. private:
     
152.     char root_1(int n);
     
153.     decnum& absadd(const decnum& x);
     
154.     decnum& abssub(const decnum& x);
     
155.     bool absge(const decnum& x);
     
156. };
     
157. 
     

复制代码

decnum.cpp

1. 
   
2. #include "decnum.h"
   
3. 
   
4. decnum&
   
5. decnum::absadd(const decnum& x)
   
6. {
   
7.     int i, max;
   
8.     char carry = 0, ch;
   
9. 
   
10.     if(x.num == 0) return *this;
    
11.     if(num < x.num)
    
12.         max = x.num + 1;
    
13.     else
    
14.         max = num + 1;
    
15.     if(max > cap)
    
16.     {
    
17.         cap = max;
    
18.         char *newval = new char[cap];
    
19.         memcpy(newval, val, num);
    
20.         memset(newval+num, 0, cap - num);
    
21.         delete[] val;
    
22.         val = newval;
    
23.     }
    
24.     else
    
25.     {
    
26.         memset(val+num, 0, max - num);
    
27.     }
    
28.     num = max-1;
    
29.     for(i=0; i<x.num; i++) {
    
30.         ch = val[i] + x.val[i] + carry;
    
31.         if(ch > 9) {
    
32.             carry = 1;
    
33.             val[i] = ch - 10;
    
34.         }
    
35.         else {
    
36.             carry = 0;
    
37.             val[i] = ch;
    
38.         }
    
39.     }
    
40.     for(; i<=num && carry == 1; i++) {
    
41.         ch = val[i] + 1;
    
42.         if(ch > 9) {
    
43.             carry = 1;
    
44.             val[i] = ch - 10;
    
45.         }
    
46.         else {
    
47.             carry = 0;
    
48.             val[i] = ch;
    
49.         }
    
50.     }
    
51.     if(i>num) num = i;
    
52.     return *this;
    
53. }
    
54. 
    
55. decnum&
    
56. decnum::abssub(const decnum& x)
    
57. {
    
58.     if(x.num == 0) return *this;
    
59.     int i;
    
60.     char carry = 0, ch;
    
61.     for(i=0; i<x.num; i++) {
    
62.         ch = val[i] - x.val[i] - carry;
    
63.         if(ch < 0) {
    
64.             carry = 1;
    
65.             val[i] = ch + 10;
    
66.         }
    
67.         else {
    
68.             carry = 0;
    
69.             val[i] = ch;
    
70.         }
    
71.     }
    
72.     for(; i<num && carry == 1; i++) {
    
73.         ch = val[i] - 1;
    
74.         if(ch < 0) {
    
75.             carry = 1;
    
76.             val[i] = ch + 10;
    
77.         }
    
78.         else {
    
79.             carry = 0;
    
80.             val[i] = ch;
    
81.         }
    
82.     }
    
83.     for(i=num; i>0 && val[i-1] == 0; i--);
    
84.     num = i;
    
85.     return *this;
    
86. }
    
87. 
    
88. bool
    
89. decnum::absge(const decnum& x)
    
90. {
    
91.     if(num > x.num) return true;
    
92.     if(num < x.num) return false;
    
93.     for(int i=num-1; i >= 0; i--)
    
94.         if(val[i] > x.val[i])
    
95.             return true;
    
96.         else if(val[i] < x.val[i])
    
97.             return false;
    
98.     return true;
    
99. }
    
100. 
     
101. decnum&
     
102. decnum::operator+=(const decnum& x)
     
103. {
     
104.     if(x.sign == sign)
     
105.         return absadd(x);
     
106.     else if(absge(x))
     
107.         return abssub(x);
     
108.     else {
     
109.         decnum tmp(*this);
     
110.         *this = x;
     
111.         return abssub(tmp);
     
112.     }
     
113. }
     
114. 
     
115. decnum&
     
116. decnum::operator-=(const decnum& x)
     
117. {
     
118.     if(x.sign != sign)
     
119.         return absadd(x);
     
120.     else if(absge(x))
     
121.         return abssub(x);
     
122.     else {
     
123.         decnum tmp(*this);
     
124.         *this = x;
     
125.         return abssub(tmp);
     
126.     }
     
127. }
     
128. 
     
129. decnum&
     
130. decnum::operator*=(const decnum& x)
     
131. {
     
132.     if(num == 0) return *this;
     
133.     if(x.num == 0) {
     
134.         num = 0;
     
135.         return *this;
     
136.     }
     
137.     if(sign == x.sign)
     
138.         sign = 0;
     
139.     else
     
140.         sign = 1;
     
141.     int mul, i, n, newcap, max;
     
142.     char ch, carry;
     
143.     char *newval = new char[num + x.num];
     
144.     newcap = num + x.num;
     
145.     memset(newval, 0, num + x.num);
     
146. 
     
147.     decnum a, b;
     
148.     char *ptr;
     
149.     for(i=0; i<num && val[i] == 0; i++);
     
150.     int na = i;
     
151.     a.val = val + i;
     
152.     a.num = num - i;
     
153.     for(i=0; i<num && x.val[i] == 0; i++);
     
154.     int nb = i;
     
155.     b.val = x.val + i;
     
156.     b.num = x.num - i;
     
157.     ptr = newval + na + nb;
     
158. 
     
159.     for(n=0; n <= a.num + b.num - 2; n++) {
     
160.         mul = 0;
     
161.         if(n > b.num - 1)
     
162.             i = n - b.num + 1;
     
163.         else
     
164.             i=0;
     
165.         max = n < a.num-1 ? n : a.num-1;
     
166.         for(; i<=max; i++)
     
167.             mul += a.val[i]*b.val[n-i];
     
168.         carry = 0;
     
169.         for(i=n; mul > 0 || carry > 0; mul /= 10, i++) {
     
170.             ch = ptr[i] + mul % 10 + carry;
     
171.             if(ch > 9) {
     
172.                 carry = 1;
     
173.                 ptr[i] = ch - 10;
     
174.             }
     
175.             else
     
176.             {
     
177.                 carry = 0;
     
178.                 ptr[i] = ch;
     
179.             }
     
180.         }
     
181.     }
     
182.     for(i=a.num + b.num; i>0 && ptr[i-1] == 0; i--);
     
183.     num = i + na + nb;
     
184.     if(cap >= num) {
     
185.         memcpy(val, newval, num);
     
186.         delete[] newval;
     
187.     }
     
188.     else {
     
189.         cap = newcap;
     
190.         delete[] val;
     
191.         val = newval;
     
192.     }
     
193.     a.val = b.val = NULL;
     
194.     return *this;
     
195. }
     
196. 
     
197. decnum&
     
198. decnum::operator/=(const decnum& x)
     
199. {
     
200.     char ch, carry, fac;
     
201.     decnum tmp;
     
202.     int i;
     
203.     if(x.num == 0) return *this;
     
204.     if(num < x.num) {
     
205.         num = 0;
     
206.         return *this;
     
207.     }
     
208.     if(sign == x.sign)
     
209.         sign = 0;
     
210.     else
     
211.         sign = 1;
     
212.     char *newval = new char[num - x.num + 1];
     
213.     memset(newval, 0, num - x.num + 1);
     
214.     carry = 0;
     
215.     fac = x.val[x.num-1] + 1;
     
216.     tmp.val = val + num - x.num + 1;
     
217.     tmp.cap = tmp.num = x.num -1;
     
218.     for(i=num-1; i>= x.num-1; i--) {
     
219.         tmp.val--;
     
220.         tmp.num++;
     
221.         ch = (carry * 10 + val[i]) / fac;
     
222.         tmp  -= x * ch;
     
223.         while(tmp >= x) {
     
224.             tmp -= x;
     
225.             ch++;
     
226.         }
     
227.         newval[i-x.num+1] = ch;
     
228.         carry = val[i];
     
229.     }
     
230.     tmp.val = NULL;
     
231.     for(i=num-x.num+1; i>0 && newval[i-1] == 0; i--);
     
232.     num = i;
     
233.     delete[] val;
     
234.     val = newval;
     
235.     return *this;
     
236. }
     
237. 
     
238. decnum&
     
239. decnum::operator%=(const decnum& x)
     
240. {
     
241.     char ch, carry, fac;
     
242.     decnum tmp;
     
243.     int i;
     
244.     if(x.num == 0) return *this;
     
245.     if(num < x.num) return *this;
     
246. 
     
247.     carry = 0;
     
248.     fac = x.val[x.num-1] + 1;
     
249.     tmp.val = val + num - x.num + 1;
     
250.     tmp.num = x.num - 1;
     
251.     for(i=num-1; i>= x.num-1; i--) {
     
252.         tmp.val--;
     
253.         tmp.num++;
     
254.         ch = (carry * 10 + val[i]) / fac;
     
255.         tmp  -= x * ch;
     
256.         while(tmp >= x) {
     
257.             tmp -= x;
     
258.             ch++;
     
259.         }
     
260.         carry = val[i];
     
261.     }
     
262.     tmp.val = NULL;
     
263.     num = tmp.num;
     
264.     return *this;
     
265. }
     
266. 
     
267. decnum
     
268. decnum::operator+(const decnum& x) const
     
269. {
     
270.     decnum tmp = *this;
     
271.     return tmp += x;
     
272. }
     
273. 
     
274. decnum
     
275. decnum::operator-(const decnum& x) const
     
276. {
     
277.     decnum tmp = *this;
     
278.     return tmp -= x;
     
279. }
     
280. 
     
281. decnum
     
282. decnum::operator*(const decnum& x) const
     
283. {
     
284.     decnum tmp = *this;
     
285.     return tmp *= x;
     
286. }
     
287. 
     
288. decnum
     
289. decnum::operator/(const decnum& x) const
     
290. {
     
291.     decnum tmp = *this;
     
292.     return tmp /= x;
     
293. }
     
294. 
     
295. decnum
     
296. decnum::operator%(const decnum& x) const
     
297. {
     
298.     decnum tmp = *this;
     
299.     return tmp %= x;
     
300. }
     
301. 
     
302. decnum abs(const decnum& x)
     
303. {
     
304.     decnum tmp(x);
     
305.     tmp.sign = 0;
     
306.     return tmp;
     
307. }
     
308. 
     
309. decnum pow(const decnum& x, int n)
     
310. {
     
311.     decnum tmp(1), fac(x);
     
312.     for(; n>0; n>>=1) {
     
313.         if(n&0x01)
     
314.             tmp *= fac;
     
315.         fac *= fac;
     
316.     }
     
317.     return tmp;
     
318. }
     
319. 
     
320. char decnum::root_1(int n)
     
321. {
     
322.     char r = (int)(pow(1+val[num-1], 1.0/n) * pow(10,(num-1.0)/n));
     
323.     for(; r>0 && pow(decnum(r), n) > *this; r--);
     
324.     return r;
     
325. }
     
326. 
     
327. bool decnum::ispow(int n, decnum& r) const
     
328. {
     
329.     if(num == 0) {
     
330.         r.num = 0;
     
331.         return true;
     
332.     }
     
333.     if(sign == 1 && (n&1 == 0)) {
     
334.         r.num = 0;
     
335.         return false;
     
336.     }
     
337.     decnum tmp, p;
     
338.     r.cap = r.num = (num+n-1) / n;
     
339.     r.val = new char[r.num];
     
340.     r.sign = sign;
     
341.     memset(r.val, 0, r.num);
     
342.     tmp.val = val + (r.num-1)*n;
     
343.     tmp.num = num - (r.num-1)*n;
     
344.     r.val[r.num-1] = tmp.root_1(n);
     
345. 
     
346.     tmp.val = new char[r.num+1];
     
347.     tmp.cap = r.num+1;
     
348.     int v;
     
349.     p = pow(r, n);
     
350.     if(p == *this) return true;
     
351.     for(int i=r.num-2; i>=0; i--) {
     
352.         memset(tmp.val, 0, i+1);
     
353.         tmp.val[i] = 1;
     
354.         tmp.num = i+1;
     
355.         tmp += r;
     
356.         p = (*this - p) / (pow(tmp, n) - p);
     
357.         if(p.num > 1)
     
358.             v = 9;
     
359.         else if(p.num > 0)
     
360.             v = p.val[0];
     
361.         else
     
362.             v = 0;
     
363.         for(; v>=0; v--) {
     
364.             r.val[i] = v;
     
365.             p = pow(r, n);
     
366.             if(p == *this)
     
367.                 return true;
     
368.             if(p < *this)
     
369.                 break;
     
370.         }
     
371.     }
     
372.     return false;
     
373. }
     
374. 
     
375. bool decnum::ispow() const
     
376. {
     
377.     decnum r, dec2("2", 1);
     
378.     if(ispow(2, r)) return true;
     
379.     for(int n=3; r > dec2; n+=2) {
     
380.         if(ispow(n, r)) return true;
     
381.     }
     
382.     return false;
     
383. }
     
384. 
     
385. decnum
     
386. root(const decnum& x, int n)
     
387. {
     
388.     decnum r;
     
389.     x.ispow(n, r);
     
390.     return r;
     
391. }
     
392. 
     
393. decnum
     
394. div(const decnum& x, const decnum& y, decnum& r)
     
395. {
     
396.     char ch, carry, fac;
     
397.     decnum d = x, tmp;
     
398.     int i;
     
399.     if(y.num == 0) return x;
     
400.     if(d.num < y.num) {
     
401.         r = x;
     
402.         d = 0;
     
403.         return d;
     
404.     }
     
405.     char *newval = new char[d.num - y.num + 1];
     
406.     memset(newval, 0, d.num - y.num + 1);
     
407.     carry = 0;
     
408.     fac = y.val[y.num-1] + 1;
     
409.     tmp.val = d.val + d.num - y.num + 1;
     
410.     tmp.num = y.num - 1;
     
411.     for(i=d.num-1; i>= y.num-1; i--) {
     
412.         tmp.val--;
     
413.         tmp.num++;
     
414.         ch = (carry * 10 + d.val[i]) / fac;
     
415.         tmp  -= y * ch;
     
416.         while(tmp >= y) {
     
417.             tmp -= y;
     
418.             ch++;
     
419.         }
     
420.         newval[i-y.num+1] = ch;
     
421.         carry = d.val[i];
     
422.     }
     
423.     r = tmp;
     
424.     tmp.val = NULL;
     
425.     for(i=d.num-y.num+1; i>0 && newval[i-1] == 0; i--);
     
426.     d.num = i;
     
427.     delete[] d.val;
     
428.     d.val = newval;
     
429.     return d;
     
430. }
     
431. 
     
432. bool operator==(const decnum& x, const decnum&y)
     
433. {
     
434.     if(x.sign != y.sign) return false;
     
435.     if(x.num != y.num) return false;
     
436.     for(int i=0; i < x.num; i++)
     
437.         if(x.val[i] != y.val[i])
     
438.             return false;
     
439.     return true;
     
440. }
     
441. 
     
442. bool operator!=(const decnum& x, const decnum&y)
     
443. {
     
444.     return !(x==y);
     
445. }
     
446. 
     
447. bool operator>(const decnum& x, const decnum&y)
     
448. {
     
449.     if(x.sign > y.sign) return false;
     
450.     if(x.sign < y.sign) return true;
     
451.     bool retval = (x.sign == 0);
     
452.     if(x.num > y.num) return retval;
     
453.     if(x.num < y.num) return !retval;
     
454.     for(int i=x.num-1; i >= 0; i--)
     
455.         if(x.val[i] > y.val[i])
     
456.             return retval;
     
457.         else if(x.val[i] < y.val[i])
     
458.             return !retval;
     
459.     return false;
     
460. }
     
461. 
     
462. bool operator<(const decnum& x, const decnum&y)
     
463. {
     
464.     return y > x;
     
465. }
     
466. 
     
467. bool operator>=(const decnum& x, const decnum&y)
     
468. {
     
469.     if(x.sign > y.sign) return false;
     
470.     if(x.sign < y.sign) return true;
     
471.     bool retval = (x.sign == 0);
     
472.     if(x.num > y.num) return retval;
     
473.     if(x.num < y.num) return !retval;
     
474.     for(int i=x.num-1; i >= 0; i--)
     
475.         if(x.val[i] > y.val[i])
     
476.             return retval;
     
477.         else if(x.val[i] < y.val[i])
     
478.             return !retval;
     
479.     return true;
     
480. }
     
481. 
     
482. bool operator<=(const decnum& x, const decnum&y)
     
483. {
     
484.     return y >= x;
     
485. }
     
486. 
     
487. ostream& operator<<(ostream&os, const decnum& x)
     
488. {
     
489.     if(x.size() == 0)
     
490.         os << 0;
     
491.     else {
     
492.         if(x.sign == 1)
     
493.             os << "-";
     
494.         for(int i = x.size()-1; i>=0; i--)
     
495.             os << (int)x.val[i];
     
496.     }
     
497.     return os;
     
498. }
     
499. 
     

复制代码

[ 本帖最后由 yuxh 于 2006-8-23 18:11 编辑 ]

flw

传说中的沙发？

zengjin8310

8错， 对我搞科学计算有用， 测试过效率么？

zengjin8310

最好再加上超高精度的浮点数的混合运算支持

yuxh

这个本来是为大素数的测试用的，这些是要用到的基本运算
可惜我的工作与加密算法无关，纯粹是业余爱好，代码也是业余水平的。
就效率而言，比较慢的就是求n次方根这个了：
root(x, n)
设x有m位，则算法应该是O(m^3*log(m)/n)的
检测一个数是否是某个数的整数次幂:
ispow()
这个就差不多是O(m^3*log(m)^2)的了

[ 本帖最后由 yuxh 于 2006-8-22 11:17 编辑 ]

默难

支持原创
顶一下吧

aple_smx

come on

mirnshi

接口为10进制, 内部的进制采用unsigned long或unsigned short，是不是更能借助逻辑运算，提高效率？

hqxyn

来凑凑热闹
decimal.h
/***************************************************************************
                          decimal.h  -  description
                             -------------------
    begin                : Wed Jan 9 2002
    copyright            : (C) 2002 by Xian Yining
    email                : hqxyn@yahoo.com.cn
***************************************************************************/

/***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************/
#ifndef DECIMAL_H
#define DECIMAL_H

#ifndef __USE_GNU
#define __USE_GNU
#endif
/*
#ifndef __USE_ISOC99
#define __USE_ISOC99
#endif
*/
#include <typeinfo>
#include <iostream>
#include <string>
#include <limits>

const unsigned DECIMAL_DEFAULT_PRE = 20,DECIMAL_DEFAULT_DEC = 6;

class decimal
{
public :
        enum Sign {PLUS=1,MINUS=-1};
        enum Stat {NOINIT=-1,OK,UPFLOW,DOWNFLOW,OVERDIGITS};
        enum Pre  {DOUBLE_PRECISION=std::numeric_limits<double>::digits10,LDOUBLE_PRECISION=std::numeric_limits<long double>::digits10};

        //构造函数
        decimal(void):sn(PLUS),val("0",exp(0),st(OK),pre(DECIMAL_DEFAULT_PRE),dec(DECIMAL_DEFAULT_DEC) {}
        decimal(const std::string &,const unsigned int p=DECIMAL_DEFAULT_PRE,const unsigned int d=DECIMAL_DEFAULT_DEC) ;
        decimal(const char* cstr,const unsigned int p=DECIMAL_DEFAULT_PRE,const unsigned int d=DECIMAL_DEFAULT_DEC) ;
        decimal(const int,const unsigned int p=DECIMAL_DEFAULT_PRE,const unsigned int d=DECIMAL_DEFAULT_DEC) ;
        decimal(const unsigned int,const unsigned int p=DECIMAL_DEFAULT_PRE,const unsigned int d=DECIMAL_DEFAULT_DEC) ;
        decimal(const long,const unsigned int p=DECIMAL_DEFAULT_PRE,const unsigned int d=DECIMAL_DEFAULT_DEC) ;
        decimal(const long long,const unsigned int p=DECIMAL_DEFAULT_PRE,const unsigned int d=DECIMAL_DEFAULT_DEC) ;
        decimal(const unsigned long,const unsigned int p=DECIMAL_DEFAULT_PRE,const unsigned int d=DECIMAL_DEFAULT_DEC) ;
        decimal(const unsigned long long,const unsigned int p=DECIMAL_DEFAULT_PRE,const unsigned int d=DECIMAL_DEFAULT_DEC) ;
        decimal(const double,const unsigned int p=DECIMAL_DEFAULT_PRE,const unsigned int d=DECIMAL_DEFAULT_DEC) ;
        decimal(const long double,const unsigned int p=DECIMAL_DEFAULT_PRE,const unsigned int d=DECIMAL_DEFAULT_DEC) ;
        decimal(const decimal& d):sn(d.sn),val(d.val),exp(d.exp),st(d.st),pre(d.pre),dec(d.dec) {}
        virtual ~decimal(){}
        //赋值
        decimal& operator=(const decimal& ;
        //算术运算
        decimal& operator +=(const decimal& ;
        decimal& operator -=(const decimal& ;
        decimal& operator *=(const decimal& ;
        decimal& operator /=(const decimal& ;
//        decimal& operator %=(const decimal& ;

        //比较运算符
        bool le(const decimal& const ;
        bool eq(const decimal& const ;
        bool gt(const decimal& const ;
       
        decimal& operator-(void) {sn=((sn==PLUS)?MINUSLUS);return *this;}
        decimal& operator+(void) {return *this;}
        //杂项函数
        virtual std::string toString() const;
        virtual std::string toShortStr() const;
        virtual std::string toString(const unsigned int len,const int de) const;
                                                                //在len长度内转为十进小数字符串，超常则返回‘＊’串
        virtual std::string toEString(const unsigned int len=0) const;        //在len长度内转为科学表示法字符串，超常则返回‘＊’串
        bool ok() const {return (st==OK)?true:false;}                //数字是否有效
        bool zero() const {return (val=="0")?true:false ;}        //数字是否为0
        virtual decimal& round(int r) ;
        virtual decimal& round() ;        //按dec指定的位数四舍五入
       
        Sign getSn() const {return sn;}
        const std::string &getVal() const {return val;}
        int getExp() const {return exp;}
        Stat getSt() const {return st;}
        unsigned getPre() const {return pre;}
        unsigned getDec() const {return dec;}
/****************
*   内部子程序   *
****************/
protected :
        decimal& decReg() ;
       
        decimal& decAdd(const decimal&);
        decimal& decSub(const decimal&);
        decimal& decMulti(const decimal&) ;
        decimal& decDiv(const decimal&);

        void valDiv(std::string& s1,const std::string& s2,const unsigned len) ;
        char valMult(std::string& s1,const std::string& s2) ;
        void valAdd(std::string& s1,int &p1,const std::string& s2,int p2) ;
        int valSub(std::string& s1,int &e1,const std::string& s2,const int e2);
       
        int digitAdd(char& c1,const char c2,const int car=0) ;
        int digitSub(char& c1,const char c2,const int b=0) ;
        char digitMult(char& c1,const char c2,const char m) ;
       
        int valCmp(const std::string& s1,const int e1,const std::string& s2,const int e2) const;
       
        void setSn(Sign s) {sn=s;}
        void setVal(const std::string &s) {val=s;}
        void setExp(int i) {exp=i;}
        void setSt(Stat s) {st=s;}
        void setPre(unsigned u) {pre=u;}
        void setDec(unsigned u) {dec=u;}
private :
        Sign                sn;        //符号
        std::string        val;        //有效尾数
        int                 exp;        //小数点位置（指数）
        //以下为辅助参数
        Stat                st;        //状态
        unsigned int        pre;        //精度(最大有效数字位数)
        unsigned int        dec;        //保留小数位数
       
};

/*******************
*   协作函数       *
*******************/
decimal round(const decimal& ,const int) ;
//算术运算
decimal operator +(const decimal&,const decimal&) ;
decimal operator -(const decimal&,const decimal&) ;
decimal operator *(const decimal&,const decimal&) ;
decimal operator /(const decimal&,const decimal&) ;
//        friend decimal& operator %(const decimal&,const decimal&) ;
//比较运算符
bool operator  <(const decimal&,const decimal&) ;
bool operator <=(const decimal&,const decimal&) ;
bool operator ==(const decimal&,const decimal&) ;
bool operator >=(const decimal&,const decimal&) ;
bool operator  >(const decimal&,const decimal&) ;
bool operator !=(const decimal&,const decimal&) ;
//流
std:stream& operator <<(std:stream&,const decimal&) ;
//unsigned int midDigits(const decimal& ,const decimal& ) ;

#endif //DECIMAL_H

[ 本帖最后由 hqxyn 于 2006-8-22 19:54 编辑 ]

hqxyn

money.h
/***************************************************************************
                          decimal.cpp  -  description
                             -------------------
    begin                : Wed Jan 9 2002
    copyright            : (C) 2002 by Xian Yining
    email                : hqxyn@yahoo.com.cn
***************************************************************************/

/***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************/
#ifndef _MONEY_H
#define _MONEY_H

#include "decimal.h"

const int MONEY_DEFAULT_DEC = 2;

class money : public decimal {
public :
money():decimal(0,DECIMAL_DEFAULT_PRE,MONEY_DEFAULT_DEC) {};
money(const char* cstr,const unsigned int p=DECIMAL_DEFAULT_PRE)
                :decimal(cstr,p,MONEY_DEFAULT_DEC) {round();} ;
money(const int i,const unsigned int p=DECIMAL_DEFAULT_PRE)
                :decimal(i,p,MONEY_DEFAULT_DEC){round();} ;
money(const unsigned int ui,const unsigned int p=DECIMAL_DEFAULT_PRE)
                :decimal(ui,p,MONEY_DEFAULT_DEC){round();} ;
money(const long l,const unsigned int p=DECIMAL_DEFAULT_PRE)
                :decimal(l,p,MONEY_DEFAULT_DEC){round();} ;
money(const long long ll,const unsigned int p=DECIMAL_DEFAULT_PRE)
                :decimal(ll,p,MONEY_DEFAULT_DEC){round();} ;
money(const unsigned long ul,const unsigned int p=DECIMAL_DEFAULT_PRE)
                :decimal(ul,p,MONEY_DEFAULT_DEC){round();} ;
money(const unsigned long long ull,const unsigned int p=DECIMAL_DEFAULT_PRE)
                :decimal(ull,p,MONEY_DEFAULT_DEC){round();} ;
money(const double db,const unsigned int p=DECIMAL_DEFAULT_PRE)
                :decimal(db,p,MONEY_DEFAULT_DEC){round();} ;
money(const long double ld,const unsigned int p=DECIMAL_DEFAULT_PRE)
                :decimal(ld,p,MONEY_DEFAULT_DEC){round();} ;
money(const decimal& d)
                :decimal(0,d.getPre(),MONEY_DEFAULT_DEC) {
                setSn(d.getSn());
                setVal(d.getVal());
                setExp(d.getExp());
                round();}
//赋值d.toEString().c_str()

money& operator=(const decimal& d) {
        //精度定义(pre)和保留小数位数(dec)在变量定义时确定，?新值时不变。
        setSn(d.getSn());
        setVal(d.getVal());
        setExp(d.getExp());
        if (getVal().size()>getPre()) {setSt(OVERDIGITS);}
        else setSt(d.getSt());
        round();
        return *this;
}
};
#endif //_MONEY_H

[ 本帖最后由 hqxyn 于 2006-8-22 10:38 编辑 ]