大数四则运算

快来打我* 2022-07-17 04:17 274阅读 0赞 
  1. .cpp
  2. #include"BigData.h"
  4. BigData::BigData(INT64 value)
  5. :_value(value)
  6. {
  7.           INT64ToString(); //构造函数时将数字转换为字符串
  8. }
  10. BigData::BigData(const char* pData)//对大数进行处理.
  11. {
  12.            //几种情况："     ","+123456","00001234","12345xyz","123456789";
  13.            if (NULL == pData)  //如果是空
  14.           {
  15.                     assert(false );  //断言false，返回
  16.                     return;
  17.           }
  18.            char* pStr = (char *)pData;
  19.            char cSymbol = pData [0];//第一位
  20.            if ('+' == cSymbol || '-' == cSymbol)
  21.           {
  22.                    pStr++;  //后移
  23.           }
  24.            else if (cSymbol >= '0' && cSymbol <= '9')
  25.           {
  26.                    cSymbol = '+';  //将符号位置为+
  27.           }
  28.            else
  29.                     return;
  30.            //处理"000000000000001234" 情况
  31.            while ('0' == *pStr)
  32.           {
  33.                    pStr++;
  34.           }
  35.            //处理 带字母的情况
  36.           _strData.resize(strlen( pData) + 1);//string中resize()函数改变本字符串的大小
  37.           _strData[0] = cSymbol; //第一位存放符号位
  38.           _value = 0;
  39.            int icount = 1;
  40.            while (*pStr >= '0' && *pStr <= '9')  //字母不处理，丢弃
  41.           {
  42.                    _value = 10 * _value + *pStr - '0';
  43.                    _strData[icount++] = *pStr;
  44.                    pStr++;
  45.           }
  46.           _strData.resize(icount); //将本字符串的大小调到icount
  48.            if ('-' == cSymbol)   //负数
  49.           {
  50.                    _value = 0 - _value; //负值
  51.           }
  52. }
  54. bool BigData ::IsINT64OverFlow()const//溢出判断
  55. {//64位中数字范围为：[-Ox8FFFFFFF FFFFFFFF，Ox7FFFFFFF FFFFFFFF]
  56.           std:: string temp = "+9223372036854775807" ;
  57.            if ('-' == _strData[0]) 
  58.           {
  59.                    temp = "-9223372036854775808";
  60.           }
  61.            //1.比较该大数与边界的size。2.相等时进行字符串直接比较
  62.            if (_strData.size() < temp.size() || _strData.size() == temp.size() && _strData <= temp)
  63.                     return true ;
  64.            else
  65.                     return false ;
  66. }
  67. void BigData ::INT64ToString()//将value转换为字符串
  68. {//append()在字符串的末尾添加num个字符ch-----basic_string &(append(size_t num,char ch))
  69.            char cSymbol = '+' ;  //正号
  70.            if (_value < 0)
  71.           {
  72.                    cSymbol = '-';
  73.           }
  74.            //12345->"54321"
  75.            INT64 temp = _value;
  76.           _strData.append(1, cSymbol);  //先添加符号位
  77.            if (cSymbol == '-' )//负数转变成正数再模除
  78.           {
  79.                    temp = 0 - temp;
  80.           }
  81.            while (temp)
  82.           {
  83.                    _strData.append(1, temp % 10 + '0');
  84.                    temp /= 10;
  85.           }
  86.            //"54321"->"12345" 
  87.            char* pLeft = (char *)_strData.c_str() + 1;
  88.            char* pRight = pLeft + _strData.size() - 2;//包含符号位，故减2
  89.            while (pLeft < pRight)  //倒序交换
  90.           {
  91.                     char tmp = *pLeft;
  92.                    *pLeft = *pRight;
  93.                    *pRight = tmp;
  94.                    pLeft++;
  95.                    pRight--;
  96.           }
  97. }
  99. //operator<<
  100. std::ostream& (operator<<(std:: ostream& _cout , const BigData& bigdata))//输出大数
  101. {//判断是否溢出，'+'不需要输出
  102.            if (bigdata .IsINT64OverFlow())//没有溢出
  103.           {
  104.                     _cout << bigdata ._value << std::endl;
  105.           }
  106.            else
  107.           { //c_str()函数返回一个指向正规C字符串的指针, 内容与本字符串相同
  108.                     char* pData = (char *)bigdata._strData.c_str();
  109.                     if ('+' == pData[0])
  110.                              pData++;
  111.                     _cout << pData << std::endl;
  112.           }
  113.            return _cout ;
  114. }
  116. //operator+
  117. BigData BigData ::operator+(const BigData& bigdata )
  118. {
  119.            //两个数都没溢出，结果也没溢出，直接进行相加
  120.            if (IsINT64OverFlow() && bigdata .IsINT64OverFlow())
  121.           {
  122.                     //异号
  123.                     if (_strData[0] != bigdata ._strData[0])
  124.                    {
  125.                               return _value + bigdata ._value;
  126.                    }
  127.                     else  //同号
  128.                    { //两个数同号，没溢出的情况：如果边界是10，则10-3=7>=6 8,-10-(-3)=-7=<-6 -8
  129.                               //正数时，最大值-value>=结果，才不会溢出
  130.                               //负数时，最大负数-value<=结果，才不会溢出
  131.                               if ((_value >= 0 && (MAX_INT64 - _value >= bigdata._value)) ||
  132.                                       (_value < 0 && (MIN_INT64 - _value <= bigdata._value)))
  133.                              {
  134.                                        return _value + bigdata ._value;
  135.                              }
  136.                               else //溢出->调用溢出加法
  137.                              {
  138.                                        return BigData (Add(_strData, bigdata._strData).c_str());
  139.                              }
  140.                    }
  141.           }
  142.            //两个数至少一个溢出，结果溢出
  143.            if (_strData[0] == bigdata ._strData[0])  //同号
  144.           {
  145.                     return BigData (Add(_strData, bigdata._strData).c_str());
  146.           }
  147.            //异号
  148.            else
  149.           { //两个数异号a,b；b为正数需要换负号，b为负数需要换正号
  150.                     //将b的符号进行转换，在调用大数减法
  151.                     string _StrData = bigdata ._strData;//注意定义字符串
  152.                     if (_StrData[0] == '+' )
  153.                    {
  154.                              _StrData[0] = '-';
  155.                    }
  156.                     else
  157.                    {
  158.                              _StrData[0] = '+';
  159.                    }
  160.                     return BigData (Sub(_strData, _StrData).c_str());
  161.           }
  162. }
  163. //溢出加法
  164. std::string BigData::Add(std::string left, std:: string right )
  165. {
  166.            int iLsize = left .size();  //size
  167.            int iRsize = right .size();
  168.            if (iLsize < iRsize)//选出大的长度给iLsize
  169.           {
  170.                    std::swap( left, right );
  171.                    std::swap(iLsize, iRsize);
  172.           }
  173.           std:: string sRet;
  174.           sRet.resize(iLsize + 1); //相加不会超过较大数的size+1
  175.           sRet[0] = left[0];
  176.            char Step = 0;//进位标识符
  178.            //
  179.            //模除得到每位的数字及进位Step
  180.            for (int iIdx = 1; iIdx < iLsize; iIdx++)
  181.           {
  182.                     int cRet = left [iLsize - iIdx] + Step - '0';
  183.                     if (iIdx < iRsize)
  184.                    {
  185.                              cRet += right[iRsize - iIdx] - '0' ;//cRet转为数字：-‘0’
  186.                    }
  187.                    sRet[iLsize - iIdx + 1] = cRet % 10 + '0';//sRet比iLsize多一位,存放字符，故+‘0’
  188.                    Step = cRet / 10;
  189.           }
  190.           sRet[1] = Step + '0'; //???
  191.            return sRet;
  192. }
  194. BigData BigData ::operator-(const BigData& bigdata )
  195. {
  196.            //两个数都没溢出，结果也没溢出，相减
  197.            if (IsINT64OverFlow() && bigdata .IsINT64OverFlow())
  198.           {
  199.                     if (_strData[0] == bigdata ._strData[0])
  200.                    {
  201.                               return _value - bigdata ._value;  //
  202.                    }
  203.                     else
  204.                    {
  205.                               //两个数异号，相减没溢出
  206.                               //-10 + 3 = -7 <= -6(减式：3-(-6))；10+（-3）= 7 >= 6(减式：-3-(6))
  207.                               if (_value >= 0 && (MIN_INT64 + _value <= bigdata._value) ||
  208.                                       _value < 0 && (MAX_INT64 + _value >= bigdata._value))
  209.                              {
  210.                                        return _value + bigdata ._value;
  211.                              }
  212.                               else
  213.                              { //调用溢出加法
  214.                                        BigData(Add(_strData, bigdata._strData).c_str());
  215.                              }
  216.                    }
  217.           }
  218.            //两个数至少一个溢出，
  219.            //同号调用减法
  220.            if (_strData[0] == bigdata ._strData[0])
  221.           {
  222.                     return BigData (Sub(_strData, bigdata._strData).c_str());
  223.           }
  224.            else //异号调用加法
  225.           {
  226.                     return BigData (Add(_strData, bigdata._strData).c_str());
  227.           }
  229. }
  231. std::string BigData::Sub(std::string left, std:: string right )
  232. {
  233.            int iLsize = left .size();
  234.            int iRsize = right .size();
  235.            char cSymbol = left [0];//符号位
  236.            if (iLsize < iRsize || (iLsize == iRsize && left < right))//左边小于右边都进行交换
  237.           { //-12-(-21)=9,21-34=-13发现两数的差与减数的相反
  238.                    std::swap( left, right );
  239.                    std::swap(iLsize, iRsize);
  240.                     if (cSymbol == '-' )
  241.                    {
  242.                              cSymbol = '+';
  243.                    }
  244.                     else
  245.                    {
  246.                              cSymbol = '-';
  247.                    }
  248.           }
  249.           std:: string sRet;
  250.           sRet.resize(iLsize); //用大的长度进行开辟空间
  251.           sRet[0] = cSymbol; //保存符号位
  252.            for (int iIdx = 1; iIdx < iLsize; iIdx++)//结束标志为iLsize-1,不是iLsize
  253.           {
  254.                     //从低到高，取left每一位；
  255.                     char cRet = left [iLsize - iIdx] - '0';
  256.                     //在right范围内从低到高，取right每一位，然后相减；
  257.                     if (iIdx < iRsize)
  258.                    {
  259.                              cRet -= right[iRsize - iIdx] - '0' ;
  260.                    }
  261.                     //判断是否借位
  262.                     if (cRet < 0)
  263.                    {
  264.                               left[iLsize - iIdx - 1] -= 1; //上一位减一
  265.                              cRet += 10;  //
  266.                    }
  267.                    sRet[iLsize - iIdx] = cRet + '0';
  268.           }
  269.            return sRet;
  270. }
  272. BigData BigData ::operator*(const BigData& bigdata )
  273. {//无溢出
  274.            if (IsINT64OverFlow() && bigdata .IsINT64OverFlow())
  275.           {
  276.                     if (_strData[0] == bigdata ._strData[0])//同号
  277.                    {
  278.                               //例如:边界是10，10 / 2 = 5 > 4; 10 / -2 = -5 < -4;
  279.                               //结果不会溢出
  280.                               if (_value > 0 && MAX_INT64 / _value >= bigdata._value ||
  281.                                       _value < 0 && MAX_INT64 / _value <= bigdata._value)
  282.                              {
  283.                                        return _value*bigdata ._value;
  284.                              }
  285.                    }
  286.                     else //异号
  287.                    {
  288.                               //例如:边界是-10，-10 / 2 = -5 < -4; -10 / -2 = 5 > 4;
  289.                               //不会溢出
  290.                               if (_value>0 && MIN_INT64 / _value <= bigdata._value ||
  291.                                       _value < 0 && MIN_INT64 / _value >= bigdata._value)
  292.                              {
  293.                                        return _value*bigdata ._value;
  294.                              }
  295.                    }
  296.           }
  297.            //两数至少有一个溢出
  298.            if (_value != 0 && bigdata ._value != 0)
  299.           {
  300.                     return BigData (Mul(_strData, bigdata._strData).c_str());
  301.           }
  302. }
  303. //溢出乘法
  304. std::string BigData::Mul(std::string left, std:: string right )
  305. {
  306.            int iLsize = left .size();
  307.            int iRsize = right .size();
  308.            char cSymbol = '+' ;//确认符号位
  309.            if (left [0] != right[0])
  310.           {
  311.                    cSymbol = '-';
  312.           }
  313.            if (iLsize > iRsize)//使较小的数为left，提高效率。eg:99*12345678
  314.           {
  315.                    swap( left, right );
  316.                    swap(iLsize, iRsize);
  317.           }
  318.           std:: string sRet;
  319.            //两个数相乘最大位数为两个数位数的和，left和right中有符号位故减1
  320.           sRet.assign(iLsize + iRsize - 1, '0');//assign()为字符串赋新值'0'
  321.           sRet[0] = cSymbol;
  322.            int iDataLen = iLsize + iRsize - 1;
  323.            int ioffset = 0;//pian移位
  324.            //先取左边一位和右边相乘；再考虑移位可得到左边每位与右边相乘的结果
  325.            for (int iLdx = 1; iLdx < iLsize; iLdx++)
  326.           {
  327.                     char cLeft = left [iLsize - iLdx] - '0';
  328.                     if (cLeft == 0)//如果left中含有0，偏移量加1
  329.                    {
  330.                              ioffset++;
  331.                               continue;
  332.                    }
  333.                     char Step = 0;
  334.                     //99*999=89910+8991;
  335.                     for (int iRdx = 1; iRdx < iRsize; iRdx++)
  336.                    {
  337.                               char cRet = cLeft * (right [iRsize - iRdx] - '0') + Step;
  338.                              cRet += sRet[iDataLen - iRdx - ioffset] - '0';//cRet存放当前最终乘加的结果
  339.                              sRet[iDataLen - iRdx - ioffset] = cRet % 10 + '0';//存放字符+'0'
  340.                              Step = cRet / 10;
  341.                    }
  342.                    sRet[iDataLen - iRsize - ioffset] += Step;
  343.                    ioffset++;
  344.           }
  345.            return sRet;
  346. }
  349. BigData BigData ::operator/(const BigData& bigdata )
  350. {
  351.            //1、除数为0
  352.            if (bigdata ._strData[1] == '0')
  353.           {
  354.                     assert(false );
  355.           }
  356.            //2、两个数没溢出
  357.            if (IsINT64OverFlow() && bigdata .IsINT64OverFlow())
  358.           {
  359.                     return _value / bigdata ._value;
  360.           }
  361.            //3、除数为1或-1
  362.            if (bigdata ._value == 1 || bigdata._value == -1)
  363.           {
  364.                     return _value;
  365.           }
  366.            //4、除数和被除数相等
  367.            //data()返回内容的字符数组形式
  368.            if (strcmp(_strData.c_str() + 1, bigdata ._strData.c_str() + 1) == 0)
  369.           {
  370.                     if (_strData[0] != bigdata ._strData[0])
  371.                    {
  372.                               return BigData (INT64(-1));
  373.                    }
  374.                     return BigData (INT64(1));
  375.           }
  376.            //除数大于被除数，返回0
  377.            if (_strData.size() < bigdata ._strData.size() ||
  378.                    _strData.size() == bigdata._strData.size() &&
  379.                    strcmp(_strData.c_str() + 1, bigdata._strData.c_str() + 1) < 0)
  380.           {
  381.                     return BigData (INT64(0));
  382.           }
  383.            //调用溢出除法
  384.            return BigData (Div(_strData, bigdata._strData).c_str());
  385. }
  386. std::string BigData::Div(std::string left, std:: string right )
  387. {//此处用append()对字符串依次赋值
  388.           std:: string sRet;
  389.           sRet.append(1, '+');
  390.            if (left [0] != right[0])
  391.           {
  392.                    sRet[0] = '-';
  393.           }
  394.            char* pLeft = (char *)left.c_str() + 1;
  395.            char* pRight = (char *)right.c_str() + 1;
  396.            int DataLen = right .size() - 1;//标记相除的除数位数
  397.            int Lsize = left .size() - 1;
  398.            int Rsize = right .size() - 1;
  399.            //eg:222222/33首先取到22和33比较大小，如果大就直接相除，否则DataLen++；
  400.            for (int iIdx = 0; iIdx < Lsize;)
  401.           {
  402.                     if (!(IsLeftstrBig(pLeft, DataLen, pRight, Rsize)))//如果取到的数小于除数时，结果商0，向后再取一位
  403.                    {
  404.                              sRet.append(1, '0');
  405.                              DataLen++;
  406.                    }
  407.                     else
  408.                    {
  409.                              sRet.append(1, SubLoop(pLeft, DataLen, pRight, Rsize));//循环相减得到该位的商
  410.                               //判断pLeft中进行循环相减后依次去掉0，
  411.                               while (*pLeft == '0' && DataLen > 0)
  412.                              {
  413.                                       pLeft++;
  414.                                       DataLen--;
  415.                                       iIdx++;
  416.                              }
  417.                              DataLen++;
  418.                    }
  419.                     if (DataLen > Rsize + 1)//pLeft比pRight大一位结果为0，则pLeft中含有0
  420.                    {
  421.                              pLeft++;
  422.                              DataLen--;
  423.                              iIdx++;
  424.                    }
  425.                     if (DataLen + iIdx > Lsize)//判断是否除法结束
  426.                               break;
  427.           }
  428.            return sRet;
  429. }
  430. //循环相减
  431. char BigData ::SubLoop(char* pLeft, int Lsize, const char * pRight, int Rsize)
  432. {
  433.            assert(pLeft && pRight);
  434.            char cRet = 0;
  435.            while (IsLeftstrBig(pLeft , Lsize, pRight, Rsize ))//直到被减数小于减数停止运算
  436.           {
  437.                     for (int iIdx = 0; iIdx < Rsize; iIdx++) //进行减运算
  438.                    {
  439.                               char ret = pLeft [Lsize - iIdx - 1] - '0';
  440.                              ret -= pRight[Rsize - iIdx - 1] - '0';
  441.                               if (ret < 0)
  442.                              {
  443.                                        pLeft[Lsize - iIdx - 2] -= 1;
  444.                                       ret += 10;
  445.                              }
  446.                               pLeft[Lsize - iIdx - 1] = ret + '0';
  447.                    }
  448.                     while (*pLeft == '0'&& Lsize>0)
  449.                    {
  450.                               pLeft++;
  451.                               Lsize--;
  452.                    }
  453.                    cRet++;
  454.           }
  455.            return cRet + '0' ;
  456. }
  458. //判断是否left大于right
  459. bool BigData ::IsLeftstrBig(const char* pLeft , int Lsize, const char * pRight, int Rsize)
  460. {
  461.            assert(pLeft && pRight);
  462.            char* pleft = (char *)pLeft;
  463.            char* pright = (char *)pRight;
  464.            if (Lsize > Rsize && *pleft > '0')//eg:112和33
  465.           {
  466.                     return true ;
  467.           }
  468.            else if (Lsize == Rsize)//eg:57和33
  469.           {
  470.                     while (pright)
  471.                    {
  472.                               if (*pleft > *pright)
  473.                              {
  474.                                        return true ;
  475.                              }
  476.                               else if (*pleft == *pright)
  477.                              {
  478.                                       pleft++;
  479.                                       pright++;
  480.                              }
  481.                               else
  482.                                        return false ;
  483.                    }
  484.           }
  485.            return false ;
  486. }
  488. .h
  489. #ifndef BIG_DATA_H
  490. #define BIG_DATA_H
  492. #include<iostream>
  493. using namespace std;
  494. #include<assert.h>
  495. #include<string>
  497. #define UN_INTT 0xCCCCCCCCCCCCCCCC
  498. #define MAX_INT64 0x7FFFFFFFFFFFFFFF
  499. #define MIN_INT64 0x8000000000000000
  501. typedef long long INT64;
  503. //内置类型
  504. class BigData
  505. {
  506. public:
  507.           BigData( INT64 value);
  508.           BigData( const char * pData);//对大数进行处理，优化
  509.            friend std::ostream & (operator<<(std::ostream& _cout, const BigData& bigdata));//输出大数
  510. public:
  511.            //大数的四则运算
  512.            BigData operator+(const BigData& bigdata); //返回值不能传引用
  513.            BigData operator-(const BigData& bigdata);
  514.            BigData operator*(const BigData& bigdata);
  515.            BigData operator/(const BigData& bigdata);
  516.           std:: string Add(std::string left, std::string right);
  517.           std:: string Sub(std::string left, std::string right);
  518.           std:: string Mul(std::string left, std::string right);
  519.           std:: string Div(std::string left, std::string right);
  520. private:
  521.            bool IsINT64OverFlow()const ;//判断大数是否溢出
  522.            void INT64ToString();//由于值在_value中，需将_value转化成string类型
  523.            char SubLoop(char * pLeft, int Lsize, const char * pRight, int Rsize);//循环相减
  524.            bool IsLeftstrBig(const char* pLeft, int Lsize, const char* pRight, int Rsize);//判断是否left大于right
  525. private:
  526.           std:: string _strData;
  527.            INT64 _value;
  528. };
  530. #endif
  533. test.cpp
  534. #define _CRT_SECURE_NO_WARNINGS 1
  537. #include<iostream>
  538. using namespace std;
  539. #include"BigData.h"
  542. void Test1()
  543. {
  544.            //BigData b1(1234);
  545.            //BigData b2("123456");
  546.            //BigData b3("+1234567");
  547.            //BigData b4("+1234567aaaa");
  548.            //BigData b5("+");
  549.            //BigData b6("     ");
  550.            //BigData b7("-12345678");
  551.            //BigData b8("-0000000012345aaa");
  552.            //cout << b1 << endl;
  553.            //cout << b2 << endl;
  554.            //cout << b3 << endl;
  555.            //cout << b4 << endl;
  556.            //cout << b5 << endl;
  557.            //cout << b6 << endl;
  558.            //cout << b7 << endl;
  559.            //cout << b8 << endl;
  560.            //b3 = b2 + b1;
  561. }
  565. //test Add
  566. void Test2()
  567. {
  568.            /*BigData left1(1234);
  569.           BigData right1(4321);
  570.           BigData ret = (left1 + right1);
  571.           cout << ret << endl;*/
  573.            /*BigData left2(9223372036854775807);
  574.           BigData right2(2);
  575.           BigData ret = (left2 + right2);
  576.           cout << ret << endl;*/
  578.            /*BigData left3(-9223372036854775807);
  579.           cout << left3 << endl;
  580.           BigData right3(-6);
  581.           cout << right3 << endl;
  582.           BigData ret = (left3 + right3);
  583.           cout << ret << endl;*/
  585.            /*BigData left2("999999999999999999999999999999");
  586.           cout << left2 << endl;
  587.           BigData right2("111111111111111111111111111111");
  588.           cout << right2 << endl;
  589.           BigData ret = (left2 + right2);
  590.           cout << ret << endl;*/
  591. }
  593. void Test3()
  594. {
  596.            /* BigData left2(1234);
  597.           cout << left2 << endl;
  598.           BigData right2(34);
  599.           cout << right2 << endl;
  600.           BigData ret = (left2 - right2);
  601.           cout << ret << endl;*/
  603.            /*BigData left2(9223372036854775807);
  604.           cout << left2 << endl;
  605.           BigData right2(-999);
  606.           cout << right2 << endl;
  607.           BigData ret = (left2 - right2);
  608.           cout << ret << endl;*/
  611.            /*BigData left2(9223372036854775807);
  612.           cout << left2 << endl;
  613.           BigData right2(999);
  614.           cout << right2 << endl;
  615.           BigData ret = (left2 - right2);
  616.           cout << ret << endl;*/
  618.            /*BigData left2(-9223372036854775807);
  619.           cout << left2 << endl;
  620.           BigData right2(-999);
  621.           cout << right2 << endl;
  622.           BigData ret = (left2 - right2);
  623.           cout << ret << endl;*/
  626.            BigData left2("1111111111111111111111111111111111111" );
  627.           cout << left2 << endl;
  628.            BigData right2("99" );
  629.           cout << right2 << endl;
  630.            BigData ret = (left2 - right2);
  631.           cout << ret << endl;
  634.            BigData left3(9223372036854775807);
  635.           cout << left3 << endl;
  636.            BigData right3("-999" );
  637.           cout << right3 << endl;
  638.            BigData ret3 = (left3 - right3);
  639.           cout << ret3 << endl;
  642. }
  645. //test mul
  646. void Test4()
  647. {
  648.            /*BigData left2("999");
  649.           cout << left2 << endl;
  650.           BigData right2("9999999999999999999999999999999999999999");
  651.           cout << right2 << endl;
  652.           BigData ret = (left2 * right2);
  653.           cout << ret << endl;
  654.           */
  656.            /*BigData left2("-999");
  657.           cout << left2 << endl;
  658.           BigData right2("99999999999999");
  659.           cout << right2 << endl;
  660.           BigData ret = (left2 * right2);
  661.           cout << ret << endl;*/
  663. }
  664. //Div
  665. void Test5()
  666. {
  667.            /*BigData left1(1234);
  668.           BigData right1(4321);
  669.           BigData ret = (left1 / right1);
  670.           cout << ret << endl;*/
  672.            /*BigData left1(123456789);
  673.           BigData right1(4321);
  674.           BigData ret = (left1 / right1);
  675.           cout << ret << endl;*/
  677.            BigData left2("999999999999999999999999999999" );
  678.            //cout << left2 << endl;
  679.            BigData right2("111111111111111111111111111111" );
  680.            //cout << right2 << endl;
  681.            BigData ret = (left2 / right2);
  682.           cout << ret << endl;
  684. }
  685. int main()
  686. {
  688.            //Test1();
  689.            //Test2();
  690.            //Test3();
  691.            //Test4();
  692.           Test5();
  693.           system( "pause");
  694.            return 0;
  695. }

发表评论

表情：
评论列表 （有 0 条评论，274人围观）

还没有评论，来说两句吧...

相关阅读

    相关 有理数四则运算

    本题要求编写程序，计算 2 个有理数的和、差、积、商。 输入格式： 输入在一行中按照 a1/b1 a2/b2 的格式给出两个分数形式的有理数，其中分子和分母全是整型范围

    朱雀朱雀/ 0 赞/ 269 阅读