程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> C語言 >> C++ >> C++入門知識 >> C++語言十進制數,CDecimal(未完成),十進制cdecimal

C++語言十進制數,CDecimal(未完成),十進制cdecimal

編輯:C++入門知識

C++語言十進制數,CDecimal(未完成),十進制cdecimal


在C#和Java中都有存在decimal類似的十進制數字,C++中尚未發現,春節假期忙裡抽閒寫了一個玩玩,時間緊迫沒有測試,只能保證編譯通過。拋磚引玉,歡迎大家多提建議

 

當前缺陷:

1. 除法功能沒有實現

2. 沒有測試

3. 代碼比較亂沒有重構,部分命名不規范

4. 算法效率比較低

 

老規矩直接上代碼:

 

VS 2010 工程

http://files.cnblogs.com/files/GhostZCH/CDecimalProject.rar

 

h文件

 1 #ifndef _CDECIMAL_H_
 2 #define _CDECIMAL_H_
 3 
 4 #include <vector>
 5 #include <string>
 6 
 7 using namespace std;
 8 
 9 typedef char INT8;
10 typedef vector<INT8> LONG_INT;
11 
12 typedef enum 
13 {
14     SIGN_NAGETIVE = -1,
15     SIGN_POSTIVE  =  1
16 }SIGN_ENUM;
17 
18 class CDecimal
19 {
20 public:
21     CDecimal();
22     CDecimal(const CDecimal &Other);
23     CDecimal(const string &strNumber); // 建議使用
24     CDecimal(const long long int iSourceNumber); // 建議使用
25     CDecimal(const long double iSourceNumber);
26     
27     CDecimal operator + (const CDecimal &other);
28     CDecimal operator - (const CDecimal &other);
29     CDecimal operator * (const CDecimal &other);
30     CDecimal operator / (const CDecimal &other);
31 
32     bool operator == (const CDecimal &other);
33     bool operator > (const CDecimal &other);
34     bool operator < (const CDecimal &other);
35 
36     size_t IntigerLenth();
37     size_t DecamalLenth();
38 
39     SIGN_ENUM Sign();
40     bool IsPostive();
41 
42     string ToString();
43     string ToString(size_t uDecimalLenth);
44     
45     ~CDecimal();
46 
47 public:
48     static CDecimal& Ceil(CDecimal& dDecimal);
49     static CDecimal& Floor(CDecimal& dDecimal);
50     static CDecimal& Round(CDecimal& dDecimal);
51 
52 
53 private:
54     void Init(bool bIsToZero = false);
55 
56     bool IsStringRight(const string& strNumber, size_t& uPointPosition, SIGN_ENUM& emSign);
57     void SetDataByString(const string& strNumber, SIGN_ENUM emSign, size_t uPointPostion, LONG_INT& numIntiger, LONG_INT& numDecimal);
58 
59     bool IsAbsBigger(const CDecimal& oNumber1, const CDecimal& oNumber2);
60 
61     void AddVector(LONG_INT& vecNumberList1, LONG_INT& vecNumberList2);    // 加到第一個vector上
62     void TrimVector(LONG_INT& vecNUmberList);  // 去掉多余的 0
63     void GetObjByVector(CDecimal& oRlst, const LONG_INT& vecRlst , size_t uDecaimalCount);
64     LONG_INT GetVectorByObj(const CDecimal& oOther);
65 
66     CDecimal& InnerAdd(CDecimal& oRslt,  CDecimal& oOther);
67     CDecimal& InnerSub(CDecimal& oRslt,  CDecimal& oOther);
68     void InnerMuti(LONG_INT& vecRslt, const LONG_INT& vecThis, const LONG_INT& vecOther);
69 
70 private:
71     SIGN_ENUM m_emSign;
72     LONG_INT m_numIntiger;
73     LONG_INT m_numDecimal;
74 };
75 
76 #endif

 

cpp文件

  1 #include "CDecimal.h"
  2 #include <math.h>
  3 #include <sstream>
  4 
  5 const int NUM_BASE = 10; 
  6 typedef LONG_INT::iterator LongIntIterator;
  7 
  8 inline size_t Min(size_t a, size_t b)
  9 {
 10     return a > b ? b : a;
 11 }
 12 
 13 inline size_t Max(size_t a, size_t b)
 14 {
 15     return a < b ? b : a;
 16 }
 17 
 18 /************************************************************************/
 19 /*           構造析構函數                                                                                                                      */
 20 /************************************************************************/
 21 void CDecimal::Init(bool bIsToZero)
 22 {
 23     m_emSign = SIGN_POSTIVE;
 24     m_numIntiger.clear();
 25     m_numDecimal.clear();
 26 
 27     if(bIsToZero)
 28     {
 29         m_numIntiger.push_back(0);
 30     }
 31 }
 32 
 33 bool CDecimal::IsStringRight(const string& strNumber, size_t& uPointPosition, SIGN_ENUM& emSign)
 34 {
 35     if(string::npos != strNumber.find_first_not_of("-0123456789."))
 36     {
 37         return false;
 38     }
 39 
 40     // 小數點的位置和個數
 41     uPointPosition = strNumber.find_first_of('.');
 42     if(uPointPosition != string::npos && uPointPosition != strNumber.find_last_of('.'))
 43     {
 44         return false;
 45     }
 46 
 47     //負號的位置和個數
 48     size_t uSignPostion = strNumber.find_first_of('-');
 49 
 50     if(uSignPostion == string::npos)
 51     {
 52         // 不存在
 53         emSign = SIGN_POSTIVE;
 54         return true;
 55     }
 56 
 57     if(uSignPostion != strNumber.find_last_of('-'))
 58     {
 59         // 多個符號
 60         return false;
 61     }
 62 
 63     emSign = SIGN_NAGETIVE;
 64     return true;
 65 }
 66 
 67 void CDecimal::SetDataByString(const string& strNumber, SIGN_ENUM emSign, size_t uPointPostion, LONG_INT& numIntiger, LONG_INT& numDecimal)
 68 {
 69     size_t uStartPos = (uPointPostion == string::npos) ? (strNumber.length() - 1) : (uPointPostion - 1);
 70     size_t uEndPos   = (emSign == SIGN_NAGETIVE) ? 1 : 0;
 71 
 72     //整數部分
 73     for(size_t u = uStartPos; u >= uEndPos && u < strNumber.length(); --u)
 74     {
 75         numIntiger.push_back((INT8)(strNumber[u] - '0'));
 76     }
 77 
 78     //小數部分
 79     if(uPointPostion == string::npos)
 80     {
 81         return;
 82     }
 83 
 84     uStartPos = uPointPostion + 1;
 85     uEndPos   = strNumber.length() - 1;
 86     for(size_t u = uStartPos; u <= uEndPos; ++u)
 87     {
 88         numIntiger.push_back((INT8)(strNumber[u] - '0'));
 89     }
 90 }
 91 
 92 // 構造函數
 93 
 94 CDecimal::CDecimal()
 95 {
 96     Init(true);
 97 }
 98 
 99 CDecimal::CDecimal(const CDecimal &Other)
100 {
101     Init();
102     m_emSign = Other.m_emSign;
103     m_numIntiger = Other.m_numIntiger;
104     m_numDecimal = Other.m_numDecimal;
105 }
106 
107 CDecimal::CDecimal(const string &strNumber)
108 {
109     size_t uPointPosition = 0;
110     SIGN_ENUM emSign = SIGN_POSTIVE;
111 
112     if(!IsStringRight(strNumber, uPointPosition, emSign))
113     {
114         Init(true);
115         return;
116     }
117 
118     Init();
119     m_emSign = emSign;
120 
121     SetDataByString(strNumber, emSign, uPointPosition, m_numIntiger, m_numDecimal);
122 }
123 
124 CDecimal::CDecimal(const long long int iSourceNumber)
125 {
126     long long int iTmp = (iSourceNumber >= 0) ? iSourceNumber : -iSourceNumber;
127 
128     Init();
129 
130     m_emSign = (iSourceNumber >= 0) ? SIGN_POSTIVE : SIGN_NAGETIVE;
131 
132     while(0 != iTmp)
133     {
134         m_numIntiger.push_back((INT8)(iTmp % NUM_BASE));
135         iTmp /= NUM_BASE;
136     }
137 }
138 
139 CDecimal::CDecimal(const long double dSourceNumber)
140 {
141     long double dDecimalPart = 0;
142     long double dIntigerPart = dSourceNumber;
143 
144     Init();
145     if(dSourceNumber < 0)
146     {
147         m_emSign = SIGN_NAGETIVE;
148         dIntigerPart = -dIntigerPart;
149     }
150 
151     dIntigerPart = floor(dIntigerPart);
152     dDecimalPart = abs(dSourceNumber) - dIntigerPart;
153 
154     // 整數部分,每次都會floor 可以直接與0比較
155     while(dIntigerPart != 0)
156     {
157         long double dTmp = dIntigerPart;
158         dIntigerPart = floor(dIntigerPart / 10);
159         m_numIntiger.push_back((INT8)(dTmp - dIntigerPart * 10));
160     }
161 
162     // 小數部分,可能出現是循環或者丟失精度
163     while(dDecimalPart != 0)
164     {
165         dDecimalPart = dDecimalPart * 10;
166         long double dTmp = floor(dDecimalPart);
167         m_numDecimal.push_back((INT8)dTmp);
168         dDecimalPart -= dTmp;
169     }
170 }
171 
172 CDecimal::~CDecimal()
173 {
174     Init();
175 }
176 
177 /************************************************************************/
178 /*           操作符函數                                                                                                                           */
179 /************************************************************************/
180 void CDecimal::AddVector(LONG_INT& vecNumberList1, LONG_INT& vecNumberList2)
181 {
182     if(vecNumberList1.size() < vecNumberList2.size())
183     {
184         for(size_t u = 0; u < vecNumberList1.size(); ++u)
185         {
186             vecNumberList1[u] += vecNumberList2[u];
187         }
188         for(size_t u = vecNumberList1.size(); u < vecNumberList2.size(); ++u)
189         {
190             vecNumberList1.push_back(vecNumberList2[u]);
191         }
192         return;
193     }
194 
195     for(size_t u = 0; u < vecNumberList2.size(); ++u)
196     {
197         vecNumberList1[u] += vecNumberList2[u];
198     }
199 }
200 
201 void CDecimal::TrimVector(LONG_INT& vecNUmberList)
202 {
203     size_t size = vecNUmberList.size();
204     for (size_t u = 0; u < size ; u++)
205     {
206         if (0 == vecNUmberList[size - u - 1])
207         {
208             vecNUmberList.pop_back();
209         }
210     }
211 }
212 
213 CDecimal& CDecimal::InnerAdd(CDecimal& oRslt, CDecimal& oOther)
214 {
215     AddVector(oRslt.m_numIntiger, oOther.m_numIntiger);
216     AddVector(oRslt.m_numDecimal, oOther.m_numDecimal);
217 
218     size_t size = oRslt.m_numDecimal.size();
219     if (size > 0)
220     {
221         for (size_t u = 0; (u + 1) <  size ; u++)
222         {
223             if (oRslt.m_numDecimal[size - u - 1] >= NUM_BASE)
224             {
225                 oRslt.m_numDecimal[size - u - 2] += 1;
226                 oRslt.m_numDecimal[size - u - 1] %= NUM_BASE;
227             }
228         }
229         if (oRslt.m_numDecimal[0] >= NUM_BASE)
230         {
231             oRslt.m_numIntiger[0] += 1;
232             oRslt.m_numDecimal[0] %= NUM_BASE;
233         }
234         TrimVector(oRslt.m_numDecimal);
235     }
236 
237     size = oRslt.m_numIntiger.size();
238     for (size_t u = 0; (u + 1) < size; u++)
239     {
240         if (oRslt.m_numIntiger[u] >= NUM_BASE)
241         {
242             oRslt.m_numIntiger[u + 1] += 1;
243             oRslt.m_numIntiger[u] %= NUM_BASE;
244         }
245     }
246     if (oRslt.m_numIntiger[size - 1] >= NUM_BASE)
247     {
248         oRslt.m_numIntiger.push_back(1);
249     }
250 
251     return oRslt;
252 }
253 
254 CDecimal& CDecimal::InnerSub(CDecimal& oRslt, CDecimal& oOther)
255 {
256     size_t size = oOther.m_numDecimal.size();
257     for (size_t u = 0; u < size; u++)
258     {
259         oOther.m_numDecimal[u] = -oOther.m_numDecimal[u];
260     }
261 
262     size = oOther.m_numIntiger.size();
263     for (size_t u = 0; u < size; u++)
264     {
265         oOther.m_numIntiger[u] = -oOther.m_numIntiger[u];
266     }
267 
268     AddVector(oRslt.m_numIntiger, oOther.m_numIntiger);
269     AddVector(oRslt.m_numDecimal, oOther.m_numDecimal);
270 
271     size = oRslt.m_numDecimal.size();
272     if (size > 0)
273     {
274         for (size_t u = 0; (u + 1)< size; u++)        // size >= 2
275         {
276             if (oRslt.m_numDecimal[size - u - 1] < 0)
277             {
278                 oRslt.m_numDecimal[size - u - 2] -= 1; 
279                 oRslt.m_numDecimal[size - u - 1] += NUM_BASE;
280             }
281         }
282         if (oRslt.m_numDecimal[0] < 0)
283         {
284             oRslt.m_numDecimal[0]+= NUM_BASE;
285             oRslt.m_numIntiger[0] -= 1;
286         }
287     }
288 
289     size = oRslt.m_numIntiger.size();
290     for (size_t u = 0; (u + 1) < size; u++)        // size >= 2
291     {
292         if (oRslt.m_numDecimal[u] < 0)
293         {
294             oRslt.m_numDecimal[u + 1] -= 1; 
295             oRslt.m_numDecimal[u] += NUM_BASE;
296         }
297     }
298     //因為進入這個函數前就已經比較過大小了,就不在考慮首位為負的情況
299 
300     TrimVector(oRslt.m_numDecimal);
301     TrimVector(oRslt.m_numIntiger);
302 
303     if (oRslt.m_numIntiger.size() == 0)
304     {
305         oRslt.m_numIntiger.push_back(0);
306     }
307 
308     return oRslt;
309 }
310 
311 CDecimal CDecimal::operator + (const CDecimal &other)
312 {
313     CDecimal oRslt = (*this);
314     CDecimal oOther = other;
315 
316     if (oRslt.m_emSign == oOther.m_emSign)
317     {
318         InnerAdd(oRslt, oOther);
319         return oRslt;
320     }
321 
322     if (IsAbsBigger(oRslt, oOther))
323     {
324         InnerSub(oRslt, oOther);
325         return oRslt;
326     }
327     else
328     {
329         InnerSub(oOther, oRslt);
330          return oOther;
331     }
332 }
333 
334 CDecimal CDecimal::operator - (const CDecimal &other)
335 {
336     CDecimal oRslt = (*this);
337     CDecimal oOther = other;
338 
339     oOther.m_emSign = (SIGN_ENUM)(- oOther.m_emSign);
340     return oRslt + oOther;
341 }
342 
343 
344 LONG_INT CDecimal::GetVectorByObj(const CDecimal& oOther)
345 {
346     LONG_INT vecNumber;
347 
348     LONG_INT::const_reverse_iterator reiter = oOther.m_numDecimal.rbegin();
349    for (; reiter != oOther.m_numDecimal.rend(); reiter++)
350    {
351        vecNumber.push_back(*reiter);
352    }
353 
354    LONG_INT::const_iterator iter = oOther.m_numIntiger.begin();
355    for (; iter != oOther.m_numIntiger.end(); iter++)
356    {
357         vecNumber.push_back(*iter);
358    }
359 
360    return vecNumber;
361 }
362 
363 void CDecimal::GetObjByVector(CDecimal& oRlst, const LONG_INT& vecRlst, size_t uDecaimalCount)
364 {
365     oRlst.m_numIntiger.clear();
366     oRlst.m_numDecimal.clear();
367     oRlst.m_numDecimal.resize(uDecaimalCount);
368 
369     size_t uPointPos =  uDecaimalCount - 1;
370     for (size_t u = 0; u < uDecaimalCount; u++)
371     {
372         oRlst.m_numDecimal.push_back(vecRlst[uPointPos - u]);
373     }
374     for (size_t u = uPointPos; u < vecRlst.size(); u++)
375     {
376         oRlst.m_numIntiger.push_back(vecRlst[u]);
377     }
378 }
379 
380 void CDecimal::InnerMuti(LONG_INT& vecRslt, const LONG_INT& vecThis, const LONG_INT& vecOther)
381 {
382     for (size_t uOther = 0; uOther < vecOther.size(); uOther++)
383     {
384         for (size_t uThis = 0; uThis < vecThis.size(); uThis++)
385         {
386             vecRslt[uOther + uThis] += vecThis[uThis] * vecOther[uOther];
387         }
388         for (size_t uRlst = 0; (uRlst + 1) < vecRslt.size(); uRlst++)
389         {
390             vecRslt[uRlst + 1] += vecRslt[uRlst] / NUM_BASE;
391             vecRslt[uRlst] %= NUM_BASE;
392         }
393     }
394 }
395 
396 CDecimal CDecimal::operator * (const CDecimal &other)
397 {
398     CDecimal oRslt;
399 
400     size_t uDecimalCount = this->m_numDecimal.size() + other.m_numDecimal.size(); // 小數部分的位數
401     size_t uRlstSize = (this->m_numIntiger.size() + this->m_numDecimal.size()) * (other.m_numIntiger.size() + other.m_numDecimal.size()) + 1;
402 
403     LONG_INT vecRlst(uRlstSize);
404     LONG_INT vecThis = GetVectorByObj(*this);
405     LONG_INT vecOther = GetVectorByObj(other);
406 
407     InnerMuti(vecRlst, vecThis, vecOther);
408 
409     GetObjByVector(oRslt, vecRlst, uDecimalCount);
410 
411     TrimVector(oRslt.m_numDecimal);
412     TrimVector(oRslt.m_numIntiger);
413 
414     oRslt.m_emSign =  (SIGN_ENUM)(this->m_emSign * other.m_emSign);
415 
416     return oRslt;
417 }
418 
419 
420 
421 CDecimal CDecimal::operator / (const CDecimal &other)
422 {
423     CDecimal oRslt;
424 
425     // TODO:
426 
427     return oRslt;
428 }
429 
430 bool CDecimal::operator == (const CDecimal &other)
431 {
432     if (this->m_emSign != other.m_emSign
433         || this->m_numDecimal.size() != other.m_numDecimal.size()
434         || this->m_numIntiger.size() != other.m_numDecimal.size())
435     {
436         return false;
437     }
438 
439     for (size_t u = 0; u < this->m_numIntiger.size(); u++)
440     {
441         if (this->m_numIntiger[u] != other.m_numIntiger[u])
442         {
443             return false;
444         }
445     }
446 
447     for (size_t u = 0; u < this->m_numDecimal.size(); u++)
448     {
449         if (this->m_numDecimal[u] != other.m_numDecimal[u])
450         {
451             return false;
452         }
453     }
454 
455     return true;
456 }
457 
458 bool CDecimal::IsAbsBigger(const CDecimal& oNumber1, const CDecimal& oNumber2)
459 {
460     if (oNumber1.m_numIntiger.size()  != oNumber2.m_numIntiger.size())
461     {
462         return oNumber1.m_numIntiger.size() > oNumber2.m_numIntiger.size();
463     }
464 
465     for (size_t u = oNumber1.m_numIntiger.size() - 1; u < oNumber2.m_numIntiger.size(); --u)
466     {
467         if (oNumber1.m_numIntiger[u] == oNumber2.m_numIntiger[u])
468         {
469             continue;
470         }
471 
472         if (oNumber1.m_numIntiger[u] > oNumber2.m_numIntiger[u])
473         {
474             return true;
475         }
476 
477         if (oNumber1.m_numIntiger[u] < oNumber2.m_numIntiger[u])
478         {
479             return false;
480         }
481     }
482 
483     size_t uDecimalLenth = Min(oNumber1.m_numDecimal.size(), oNumber2.m_numDecimal.size());
484     for (size_t u = 0; u < uDecimalLenth; ++u)
485     {
486         if (oNumber1.m_numDecimal[u] == oNumber2.m_numDecimal[u])
487         {
488             continue;
489         }
490 
491         if (oNumber1.m_numDecimal[u] > oNumber2.m_numDecimal[u])
492         {
493             return true;
494         }
495 
496         if (oNumber1.m_numDecimal[u] < oNumber2.m_numDecimal[u])
497         {
498             return false;
499         }
500     }
501 
502     return oNumber1.m_numDecimal.size() > oNumber2.m_numDecimal.size();
503 }
504 
505 bool CDecimal::operator > (const CDecimal &other)
506 {
507     if ((*this) == other)
508     {
509         return false;
510     }
511 
512     if ((SIGN_POSTIVE == this->m_emSign) && (SIGN_NAGETIVE == other.m_emSign))
513     {
514         return true;
515     }
516 
517     if ((SIGN_NAGETIVE == this->m_emSign) && (SIGN_POSTIVE == other.m_emSign))
518     {
519         return false;
520     }
521 
522     if (SIGN_POSTIVE == this->m_emSign)
523     {
524         return IsAbsBigger((*this), other);
525     }
526 
527     return !IsAbsBigger((*this), other);
528 }
529 
530 bool CDecimal::operator < (const CDecimal &other)
531 {
532     if ((*this) > other || (*this) == other)
533     {
534         return false;
535     }
536     return true;
537 }
538 
539 /************************************************************************/
540 /*           其他函數                                                                                                                               */
541 /************************************************************************/
542 size_t CDecimal::IntigerLenth()
543 {
544     return m_numIntiger.size();
545 }
546 
547 size_t CDecimal::DecamalLenth()
548 {
549     return m_numDecimal.size();
550 }
551 
552 SIGN_ENUM CDecimal::Sign()
553 {
554     return m_emSign;
555 }
556 
557 bool CDecimal::IsPostive()
558 {
559     return m_emSign == SIGN_POSTIVE;
560 }
561 
562 string CDecimal::ToString()
563 {
564     return ToString(m_numDecimal.size());
565 }
566 
567 string CDecimal::ToString(size_t uDecimalLenth)
568 {
569     string strNumber;
570     stringstream ssNumber("");
571 
572     if(SIGN_NAGETIVE == m_emSign)
573     {
574         ssNumber << '-';
575     }
576 
577     for(size_t u = m_numIntiger.size() - 1; u >= 0 && u < m_numIntiger.size(); --u)
578     {
579         ssNumber << (int)m_numIntiger[u];
580     }
581 
582     if(uDecimalLenth > 0 || m_numDecimal.size() > 0)
583     {
584         ssNumber << '.';
585     }
586 
587     if(uDecimalLenth < m_numDecimal.size())
588     {
589         for(size_t u = 0; u < uDecimalLenth; ++u)
590         {
591             ssNumber << (int)m_numDecimal[u];
592         }
593         return ssNumber.str();
594     }
595 
596     for(size_t u = 0; u < m_numDecimal.size(); ++u)
597     {
598         ssNumber << (int)m_numDecimal[u];
599     }
600     for(size_t u = m_numDecimal.size(); u < uDecimalLenth; ++u)
601     {
602         ssNumber << (int)0;
603     }
604 
605     return ssNumber.str();
606 }
607 
608 /************************************************************************/
609 /*            靜態函數區                                                                                                                          */
610 /************************************************************************/
611 
612  CDecimal& CDecimal::Ceil(CDecimal& dDecimal)
613 {
614     if (dDecimal.m_numDecimal.size() > 0)
615     {
616         dDecimal = dDecimal + 1LL;
617     }
618     dDecimal.m_numDecimal.clear();
619     return dDecimal;
620 }
621  CDecimal& CDecimal::Floor(CDecimal& dDecimal)
622  {
623      if (dDecimal.m_numDecimal.size() > 0)
624      {
625          dDecimal = dDecimal - 1LL;
626      }
627      dDecimal.m_numDecimal.clear();
628      return dDecimal;
629  }
630   
631  CDecimal& CDecimal::Round(CDecimal& dDecimal)
632  {
633      dDecimal = dDecimal + CDecimal("0.5");
634      return Floor(dDecimal);
635  }

 

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved