• C++中如何处理超长的数字（long long类型的整数都无法存储的）

    C++中如何处理超长的数字（long long类型的整数都无法存储的）

    在 C++中，如果数字超出了 long long 类型的范围，可以考虑使用字符串或第三方库（如 Boost.Multiprecision）来表示和处理超长数字。要使用第三方库需要下载并安装所需的第三方库，在此就不介绍了。

    在此介绍使用字符串表示和处理超长数字。本文将介绍使用C++字符串实现超长的数字加法、减法、乘法和除法运算。

    1.判断一个非负的超大数是奇数还是偶数，源码如下：

    1. #include   
    2. #include 
    3. using namespace std;  
    4.  
    5. int main() {  
    6. //string s = "123456789123456789123456789";
    7. cout << "请输入一个正整数：" << endl;
    8.     cin >> s;
    9.     // s.size()是字符串的长度，即由多少字符组成的， 字符串的最后一位字符即s[s.size() - 1]
    10.     char c = s[s.size() - 1];
    11.     cout << "最后一位数字是" << c << endl;  
    12.     // 将一个整数数字字符变成整数，我们只需要将它减字符'0'
    13.     int i = c - '0';
    14.     if (i % 2 == 0) {
    15.         cout << s << "是偶数";
    16.     } else {
    17.         cout << s << "是奇数";
    18.     }
    19.         
    20.     return 0;  
    21. }

    2.判断两个超大正整数的大小

    1. #include   
    2. #include   
    3.   
    4. using namespace std;  
    5.   
    6. bool Lower(string str1, string str2){     
    7.     //长度长的一定大（这里假设除了0以外，都没有前导0），长度相等则字典序小的数字更小
    8.     return str1.size()size()||(str1.size()==str2.size()&&str1
    9. } 
    10.   
    11. int main() {  
    12.     cout << "请输入两个超大正整数：" << endl;
    13. 	string a, b; 
    14. 	cin >> a >> b; 
    15.     if (Lower(a, b)){
    16.     	cout << a << "小于" << b << endl;
    17. 	}
    18. 	else{
    19. 		cout << a << "大于" << b << endl;
    20. 	}
    21. 	  
    22.     return 0;  
    23. }

    下面分别介绍加法、减法、乘法和除法运算的实现方法。特别说明，加减运算仅限非负整数的运算，因为负数的加减运算可以等价为某种形式的加法或者减法运算，故不做考虑；乘除运算只考虑大整数运算，不考虑小数的计算；除法只考虑大整数运算，计算结果精确到6位小数（6位小数后直接舍去）。

    参考https://blog.songjiahao.com/archives/382

    3. 非负大整数的加法

    大数加法的实现，模仿了我们列竖式的计算方法，从个位开始，一位一位的相加，每次考虑进位即可。由于读入的字符串0号位置为最高位，所以我们采用逆序的办法访问字符串，然后每位计算即可。同样的，因为计算时候得到的每一位都是逆序的，最后的结果要进行逆置。

    加法，可能导致最终位数多一位（最高位的进位），所以要记得处理。

    最后，我们来考虑一些特殊情况，比如两个数字都是0，或者其中有一个是0，我们就可以快速得到结果，省去了遍历过程。

    实现代码

    1. #include   
    2. #include   
    3. #include 
    4.  
    5. using namespace std; 
    6.  
    7. //判断是否为0，全部为0的数字就是0，比如00000
    8. bool CheckZero(const string &str){      //检查是否等于0
    9.     int size=str.size();                //如果全是0则为0，这里假设不会有带符号的+00000或者-00000作为输入
    10.     for(int i=0;i
    11.         if(str[i]!='0') return false;
    12.     return true;
    13. }
    14.  
    15. string Add(string str1, string str2){
    16.     //关于0的处理
    17.     if(CheckZero(str1)&&CheckZero(str2)) return "0";    //如果都是0
    18.     else if(CheckZero(str1)) return str2;               //如果有个一为0
    19.     else if(CheckZero(str2)) return str1;
    20.     string ans;
    21.     int i=str1.size()-1,j=str2.size()-1;
    22.     int flag=0;                                         //进位标记
    23.     while(i>=0||j>=0||flag){
    24.         int numa=i>=0?str1[i--]-'0':0;                  //如果所有位都访问完毕，对应的位置用0代替
    25.         int numb=j>=0?str2[j--]-'0':0;
    26.         flag=numa+numb+flag;                            //计算两位的和
    27.         ans+='0'+flag%10;                               //取个位保存在答案中
    28.         flag/=10;                                       //计算进位
    29.     }
    30.     reverse(ans.begin(),ans.end());
    31.     return ans;
    32. }
    33.  
    34. int main(){
    35. 	cout << "请输入两个正整数：" << endl;
    36. 	string a, b;
    37. 	cin >> a >> b;
    38. 	string result = Add(a, b);  
    39.     cout << "和：" << result << endl;  
    40.     return 0;  
    41. }

    4. 非负大整数的减法

    大数减法的实现，也模仿了我们列竖式的计算方法。从个位起，每次计算一位，首先根据后一位是否借位，先减去借位，然后判断当前位是否够减，如果需要借位，则向前一位借位后在减，直到运算完毕。同样的，因为我们要从个位开始计算，所以计算得到的结果必然是逆序的，最终要记得将结果逆置。

    减法，可能出现前导0，要记得清除前导零。

    最后，我们来考虑一些特殊情况，比如两个数相同或者有一个数字为0，我们可以直接得到结果，从而避免了复杂的处理过程。

    实现代码

    1. #include   
    2. #include   
    3. #include 
    4.  
    5. using namespace std; 
    6.  
    7. //判断两个超大正整数的大小 
    8. bool Lower(string str1, string str2){     
    9.     //长度长的一定大（这里假设除了0以外，都没有前导0），长度相等则字典序小的数字更小
    10.     return str1.size()size()||(str1.size()==str2.size()&&str1
    11. } 
    12.  
    13. //判断是否为0，全部为0的数字就是0，比如00000
    14. bool CheckZero(const string &str){      //检查是否等于0
    15.     int size=str.size();                //如果全是0则为0，这里假设不会有带符号的+00000或者-00000作为输入
    16.     for(int i=0;i
    17.         if(str[i]!='0') return false;
    18.     return true;
    19. }
    20.  
    21. string Sub(string str1, string str2){
    22.     //处理0的情况
    23.     if(str1==str2||(CheckZero(str1)&&CheckZero(str2))) return "0";  //如果两数相等或者都是0
    24.     else if(CheckZero(str1)) return "-"+str2;                       //如果第一个数字为0
    25.     else if(CheckZero(str2)) return str1;                           //如果第二个数字为0
    26.     //定正负
    27.     int negative=0;                     //结果的正负号
    28.     if(Lower(str1,str2)){
    29.         swap(str1,str2);                //保证str1大于str2
    30.         negative=1;                     //如果str1小于str2，则结果过为负值
    31.     }
    32.     string ans;
    33.     int i=str1.size()-1,j=str2.size()-1;//逆序开始处理
    34.     int flag=0;                         //借位标记
    35.     while(i>=0||j>=0){
    36.         int numa=i>=0?str1[i--]-'0':0;  //取每一位，因为长度可能不同所以当某一个已经读取完毕时对应位置取0
    37.         int numb=j>=0?str2[j--]-'0':0;
    38.         numa-=flag;                     //先减去借位
    39.         if(numa//如果不够减则向上一位借位（只可能借一位）
    40.             numa+=10;                   //借位并记录借位
    41.             flag=1;
    42.         }
    43.         else flag=0;                    //如果不借位，则借位标记为0
    44.         ans+='0'+numa-numb;             //计算当前位置并保存
    45.     }
    46.     i=ans.size()-1;
    47.     while(ans[i]=='0') i--;
    48.     ans=ans.substr(0,i+1);              //去除前导0,如111-110=1
    49.     if(negative) ans+='-';              //如果计算结果是负数，添加负数符号
    50.     reverse(ans.begin(),ans.end());     //因为是逆序计算得到的结果，所以需要翻转一下
    51.     return ans;
    52. }
    53.  
    54. int main(){
    55. 	cout << "请输入两个正整数：" << endl;
    56. 	string a, b;
    57. 	cin >> a >> b;
    58. 	string result = Sub(a, b);  
    59.     cout << "差： " << result << endl;     
    60.     return 0;  
    61. }

    5.大整数的乘法

    大数乘法的实现，还采用我们竖式计算的方法。从个位开始，每次计算被乘数和乘数一位的积，然后借助我们写好的大数加法实现最终结果的累加。但是大数乘法需要考虑正负的问题，所以需要对正负号进行处理，对两个数的符号使用异或最终可以确定乘积结果的正负。

    乘法，因为乘数的每一位都有相应的权值（个十百千万），因此我们对于乘数每一位的积进行运算时要考虑该位置的权值，在积的后边补充相应个数的零即可。

    最后，我们考虑一些特殊情况，比如两个数字中只要有一个是0，则结果就是0。

    实现代码

    1. #include   
    2. #include   
    3. #include 
    4.  
    5. using namespace std; 
    6.  
    7. //判断两个超大正整数的大小 
    8. bool Lower(string str1, string str2){     
    9.     //长度长的一定大（这里假设除了0以外，都没有前导0），长度相等则字典序小的数字更小
    10.     return str1.size()size()||(str1.size()==str2.size()&&str1
    11. } 
    12.  
    13. //判断是否为负，只需要判断第一位是不是负号即可，这里不考虑正号的存在，即认为不使用正号
    14. bool CheckNegative(const string &str){  //检查是否为负数
    15.     return str[0]=='-';
    16. }
    17.  
    18. //判断是否为0，全部为0的数字就是0，比如00000
    19. bool CheckZero(const string &str){      //检查是否等于0
    20.     int size=str.size();                //如果全是0则为0，这里假设不会有带符号的+00000或者-00000作为输入
    21.     for(int i=0;i
    22.         if(str[i]!='0') return false;
    23.     return true;
    24. }
    25.  
    26. string Add(string str1, string str2){
    27.     //关于0的处理
    28.     if(CheckZero(str1)&&CheckZero(str2)) return "0";    //如果都是0
    29.     else if(CheckZero(str1)) return str2;               //如果有个一为0
    30.     else if(CheckZero(str2)) return str1;
    31.     string ans;
    32.     int i=str1.size()-1,j=str2.size()-1;
    33.     int flag=0;                                         //进位标记
    34.     while(i>=0||j>=0||flag){
    35.         int numa=i>=0?str1[i--]-'0':0;                  //如果所有位都访问完毕，对应的位置用0代替
    36.         int numb=j>=0?str2[j--]-'0':0;
    37.         flag=numa+numb+flag;                            //计算两位的和
    38.         ans+='0'+flag%10;                               //取个位保存在答案中
    39.         flag/=10;                                       //计算进位
    40.     }
    41.     reverse(ans.begin(),ans.end());
    42.     return ans;
    43. }
    44.  
    45. string Mul(string str1, string str2){
    46.     if(CheckZero(str1)||CheckZero(str2)) return "0";    //如果有一个为0,则结果为0
    47.  
    48.     int negative=0,negastr1=0,negastr2=0;               //定正负
    49.     if(CheckNegative(str1)){                            //确定正负号标记，并且去掉-字符
    50.         negastr1=1; str1=str1.substr(1,str1.size()-1);
    51.     }
    52.     if(CheckNegative(str2)){
    53.         negastr2=1; str2=str2.substr(1,str2.size()-1);
    54.     }
    55.     negative=negastr1^negastr2;                         //异或运算确定结果的正负号
    56.  
    57.     string ans;
    58.     if(Lower(str1,str2)) swap(str1,str2);               //保证str1大于等于str2
    59.     int size1=str1.size(),size2=str2.size();
    60.     for(int i=size2-1;i>=0;i--){                        //遍历较小数字的每一位
    61.         string temp(size2-1-i,'0');                     //temp为str1乘以str2[i]的积，根据str2[i]的权重（个十百千万，补充对应个数的0）
    62.         int flag=0;                                     //进位标记
    63.         for(int j=size1-1;j>=0;j--){                    //temp
    64.             flag+=(str1[j]-'0')*(str2[i]-'0');
    65.             temp.push_back('0'+(flag%10));
    66.             flag/=10;
    67.         }
    68.         if(flag) temp.push_back('0'+flag);              //如果最高位还有进位
    69.         reverse(temp.begin(),temp.end());
    70.         ans=Add(ans,temp);                              //将计算结果累加到最终的结果上
    71.     }
    72.     if(negative) ans="-"+ans;                           //处理结果的正负号
    73.     return ans;
    74. }
    75.  
    76. int main(){
    77. 	cout << "请输入两个整数：" << endl;
    78. 	string a, b;
    79. 	cin >> a >> b;
    80. 	string result = Mul(a, b);  
    81.     cout << "积：" << result << endl;     
    82.     return 0;  
    83. }

    6. 大整数的除法，计算结果精确到6位小数（6位小数后直接舍去）

    如商3.700014[5800933124]

    大数除法的实现，同样采用我们除法式子的方法进行计算。首先，使用异或的方法确定结果的正负号。两个数字相除的时候，如果第一个数字大于等于第二个数字，则结果一定是大于等于1的，否则小于1。于是，为了实现小于1的结果表示，我们为结果精确到小数点后6位。这里采用的方法为：事先确定是否为纯小数，然后在第一个数字的末尾加上6个0，然后使用我们除法式子的方法进行计算。从第一个数字的头部开始，找到第一个长度能够进行商运算的数字开始，计算商并将临时的余数补足一位进行下一位商的计算，直到计算完毕。

    除法，可能遇到除数为0的情况，因此需要在计算的时候提前进行判定。另外计算过程中，计算商的方法使用大数的减法操作，因此可能会遇到0堆积的情况（长度增大），会影响到大小的比较判定，要注意处理。

    最后，我们考虑一些特殊情况，比如被除数为0的时候，可以直接输出结果0.000000。

    实现代码

    1. #include   
    2. #include   
    3. #include 
    4.  
    5. using namespace std; 
    6.  
    7. //判断两个超大正整数的大小 
    8. bool Lower(string str1, string str2){     
    9.     //长度长的一定大（这里假设除了0以外，都没有前导0），长度相等则字典序小的数字更小
    10.     return str1.size()size()||(str1.size()==str2.size()&&str1
    11. } 
    12.  
    13. //判断是否为负，只需要判断第一位是不是负号即可，这里不考虑正号的存在，即认为不使用正号
    14. bool CheckNegative(const string &str){  //检查是否为负数
    15.     return str[0]=='-';
    16. }
    17.  
    18. //判断是否为0，全部为0的数字就是0，比如00000
    19. bool CheckZero(const string &str){      //检查是否等于0
    20.     int size=str.size();                //如果全是0则为0，这里假设不会有带符号的+00000或者-00000作为输入
    21.     for(int i=0;i
    22.         if(str[i]!='0') return false;
    23.     return true;
    24. }
    25.  
    26. //大数减法
    27. string Sub(string str1, string str2){
    28.     //处理0的情况
    29.     if(str1==str2||(CheckZero(str1)&&CheckZero(str2))) return "0";  //如果两数相等或者都是0
    30.     else if(CheckZero(str1)) return "-"+str2;                       //如果第一个数字为0
    31.     else if(CheckZero(str2)) return str1;                           //如果第二个数字为0
    32.     //定正负
    33.     int negative=0;                     //结果的正负号
    34.     if(Lower(str1,str2)){
    35.         swap(str1,str2);                //保证str1大于str2
    36.         negative=1;                     //如果str1小于str2，则结果过为负值
    37.     }
    38.     string ans;
    39.     int i=str1.size()-1,j=str2.size()-1;//逆序开始处理
    40.     int flag=0;                         //借位标记
    41.     while(i>=0||j>=0){
    42.         int numa=i>=0?str1[i--]-'0':0;  //取每一位，因为长度可能不同所以当某一个已经读取完毕时对应位置取0
    43.         int numb=j>=0?str2[j--]-'0':0;
    44.         numa-=flag;                     //先减去借位
    45.         if(numa//如果不够减则向上一位借位（只可能借一位）
    46.             numa+=10;                   //借位并记录借位
    47.             flag=1;
    48.         }
    49.         else flag=0;                    //如果不借位，则借位标记为0
    50.         ans+='0'+numa-numb;             //计算当前位置并保存
    51.     }
    52.     i=ans.size()-1;
    53.     while(ans[i]=='0') i--;
    54.     ans=ans.substr(0,i+1);              //去除前导0,如111-110=1
    55.     if(negative) ans+='-';              //如果计算结果是负数，添加负数符号
    56.     reverse(ans.begin(),ans.end());     //因为是逆序计算得到的结果，所以需要翻转一下
    57.     return ans;
    58. }
    59.  
    60. string Div(string str1, string str2){
    61.     //处理除数为0的情况和被除数为0的情况
    62.     if(CheckZero(str2)) return "The divisor cannot be zero!";
    63.     else if(CheckZero(str1)) return "0.000000";
    64.  
    65.     int negative=0,negastr1=0,negastr2=0;               //定正负
    66.     if(CheckNegative(str1)){                            //确定正负号标记，并且去掉-
    67.         negastr1=1; str1=str1.substr(1,str1.size()-1);
    68.     }
    69.     if(CheckNegative(str2)){
    70.         negastr2=1; str2=str2.substr(1,str2.size()-1);
    71.     }
    72.     negative=negastr1^negastr2;                         //异或运算确定结果的正负号
    73.  
    74.     int point=0;                                        //结果是否为纯小数
    75.     if(Lower(str1,str2)) point=1;                       //如果str1小于str2，则计算为纯小数
    76.     string ans;                                         //计算结果
    77.     str1+=string(6,'0');                                //补足6个0，用于计算小数位
    78.  
    79.     int size1=str1.size(),size2=str2.size();
    80.     int i=size2-1;                                      //商第一位的位置
    81.     string temp=str1.substr(0,i);                       //从str1上取size2-1个字符
    82.     for(i;i
    83.         temp+=str1[i];                                  //从后边拿出一位，预先处理可以防止结尾处越界
    84.         int cnt=0;                                      //当前位的商，也就是temp中包含了多少个str2，使用减法                                          //如果temp不为0，则计算商
    85.         while(Lower(str2,temp)||temp==str2){            //如果当前位商不为0，则计算商
    86.             temp=Sub(temp,str2);
    87.             cnt++;
    88.         }
    89.         if(temp=="0") temp.clear();                     //如果某次计算结果为0，则清空，避免0的堆积,比如111000 111
    90.         ans.push_back('0'+cnt);                         //保存商
    91.     }
    92.     i=0;
    93.     while(ans[i]=='0') i++;
    94.     ans=ans.substr(i,ans.size()-i);                     //去除前导0
    95.     if(point){                                          //如果是纯小数,补足6位并添加小数点
    96.         int len=6-ans.size();
    97.         ans="0."+string(len,'0')+ans;
    98.     }
    99.     else ans.insert((ans.end()-6),'.');                 //如果不是小数，则只需要插入小数点       
    100.     if(negative) ans="-"+ans;                           //最后一步骤，如果是负数带上负号
    101.     return ans;
    102. }
    103.  
    104. int main(){
    105. 	cout << "请输入两个整数：" << endl;
    106. 	string a, b;
    107. 	cin >> a >> b;
    108. 	string result = Div(a, b);  
    109.     cout << "商(6位小数后直接舍去)：" << result << endl;     
    110.     return 0;  
    111. }

    7.最后，整合为大数四则运算

    加减运算仅限非负整数的运算，因为负数的加减运算可以等价为某种形式的加法或者减法运算，故不做考虑；乘除运算只考虑大整数运算，不考虑小数的计算；除法只考虑大整数运算，计算结果精确到6位小数（6位小数后直接舍去）。源码如下：

    1. #include   
    2. #include   
    3. #include 
    4.   
    5. using namespace std;  
    6.   
    7. //大数四则运算，两个参数都不能为空
    8. string Add(string str1, string str2);       //大数加法
    9. string Sub(string str1, string str2);       //大数减法
    10. string Mul(string str1, string str2);       //大数乘法
    11. string Div(string str1, string str2);       //大数除法
    12. bool Lower(string str1, string str2);       //大数比较（小于）
    13. bool CheckZero(const string &str);          //检查是不是0，比如0000认为是0
    14. bool CheckNegative(const string &str);      //检查是不是负数
    15. void ShowMenu();                            //提示菜单
    16. void ShowMenu(char choice);                 //二级菜单
    17. int main(){
    18.     string a,b;
    19.     char ch;
    20.     ShowMenu();
    21.     while(cin>>ch&&ch!='q'){                //循环打印菜单并提示用户输入
    22.         ShowMenu(ch);
    23.         cin>>a>>b;
    24.         switch(ch){
    25.             case 'a':cout<" + "<" = "<<Add(a,b)<break;
    26.             case 'b':cout<" - "<" = "<<Sub(a,b)<break;
    27.             case 'c':cout<" * "<" = "<<Mul(a,b)<break;
    28.             case 'd':cout<" / "<" = "<<Div(a,b)<break;
    29.         }
    30.         ShowMenu();
    31.     }
    32.     return 0;
    33. }
    34. string Add(string str1, string str2){
    35.     //关于0的处理
    36.     if(CheckZero(str1)&&CheckZero(str2)) return "0";    //如果都是0
    37.     else if(CheckZero(str1)) return str2;               //如果有个一为0
    38.     else if(CheckZero(str2)) return str1;
    39.     string ans;
    40.     int i=str1.size()-1,j=str2.size()-1;
    41.     int flag=0;                                         //进位标记
    42.     while(i>=0||j>=0||flag){
    43.         int numa=i>=0?str1[i--]-'0':0;                  //如果所有位都访问完毕，对应的位置用0代替
    44.         int numb=j>=0?str2[j--]-'0':0;
    45.         flag=numa+numb+flag;                            //计算两位的和
    46.         ans+='0'+flag%10;                               //取个位保存在答案中
    47.         flag/=10;                                       //计算进位
    48.     }
    49.     reverse(ans.begin(),ans.end());
    50.     return ans;
    51. }
    52. string Sub(string str1, string str2){
    53.     //处理0的情况
    54.     if(str1==str2||(CheckZero(str1)&&CheckZero(str2))) return "0";  //如果两数相等或者都是0
    55.     else if(CheckZero(str1)) return "-"+str2;                       //如果第一个数字为0
    56.     else if(CheckZero(str2)) return str1;                           //如果第二个数字为0
    57.     //定正负
    58.     int negative=0;                     //结果的正负号
    59.     if(Lower(str1,str2)){
    60.         swap(str1,str2);                //保证str1大于str2
    61.         negative=1;                     //如果str1小于str2，则结果过为负值
    62.     }
    63.     string ans;
    64.     int i=str1.size()-1,j=str2.size()-1;//逆序开始处理
    65.     int flag=0;                         //借位标记
    66.     while(i>=0||j>=0){
    67.         int numa=i>=0?str1[i--]-'0':0;  //取每一位，因为长度可能不同所以当某一个已经读取完毕时对应位置取0
    68.         int numb=j>=0?str2[j--]-'0':0;
    69.         numa-=flag;                     //先减去借位
    70.         if(numa//如果不够减则向上一位借位（只可能借一位）
    71.             numa+=10;                   //借位并记录借位
    72.             flag=1;
    73.         }
    74.         else flag=0;                    //如果不借位，则借位标记为0
    75.         ans+='0'+numa-numb;             //计算当前位置并保存
    76.     }
    77.     i=ans.size()-1;
    78.     while(ans[i]=='0') i--;
    79.     ans=ans.substr(0,i+1);              //去除前导0,如111-110=1
    80.     if(negative) ans+='-';              //如果计算结果是负数，添加负数符号
    81.     reverse(ans.begin(),ans.end());     //因为是逆序计算得到的结果，所以需要翻转一下
    82.     return ans;
    83. }
    84. string Mul(string str1, string str2){
    85.     if(CheckZero(str1)||CheckZero(str2)) return "0";    //如果有一个为0,则结果为0
    86.  
    87.     int negative=0,negastr1=0,negastr2=0;               //定正负
    88.     if(CheckNegative(str1)){                            //确定正负号标记，并且去掉-字符
    89.         negastr1=1; str1=str1.substr(1,str1.size()-1);
    90.     }
    91.     if(CheckNegative(str2)){
    92.         negastr2=1; str2=str2.substr(1,str2.size()-1);
    93.     }
    94.     negative=negastr1^negastr2;                         //异或运算确定结果的正负号
    95.  
    96.     string ans;
    97.     if(Lower(str1,str2)) swap(str1,str2);               //保证str1大于等于str2
    98.     int size1=str1.size(),size2=str2.size();
    99.     for(int i=size2-1;i>=0;i--){                        //遍历较小数字的每一位
    100.         string temp(size2-1-i,'0');                     //temp为str1乘以str2[i]的积，根据str2[i]的权重（个十百千万，补充对应个数的0）
    101.         int flag=0;                                     //进位标记
    102.         for(int j=size1-1;j>=0;j--){                    //temp
    103.             flag+=(str1[j]-'0')*(str2[i]-'0');
    104.             temp.push_back('0'+(flag%10));
    105.             flag/=10;
    106.         }
    107.         if(flag) temp.push_back('0'+flag);              //如果最高位还有进位
    108.         reverse(temp.begin(),temp.end());
    109.         ans=Add(ans,temp);                              //将计算结果累加到最终的结果上
    110.     }
    111.     if(negative) ans="-"+ans;                           //处理结果的正负号
    112.     return ans;
    113. }
    114. string Div(string str1, string str2){
    115.     //处理除数为0的情况和被除数为0的情况
    116.     if(CheckZero(str2)) return "The divisor cannot be zero!";
    117.     else if(CheckZero(str1)) return "0.000000";
    118.  
    119.     int negative=0,negastr1=0,negastr2=0;               //定正负
    120.     if(CheckNegative(str1)){                            //确定正负号标记，并且去掉-
    121.         negastr1=1; str1=str1.substr(1,str1.size()-1);
    122.     }
    123.     if(CheckNegative(str2)){
    124.         negastr2=1; str2=str2.substr(1,str2.size()-1);
    125.     }
    126.     negative=negastr1^negastr2;                         //异或运算确定结果的正负号
    127.  
    128.     int point=0;                                        //结果是否为纯小数
    129.     if(Lower(str1,str2)) point=1;                       //如果str1小于str2，则计算为纯小数
    130.     string ans;                                         //计算结果
    131.     str1+=string(6,'0');                                //补足6个0，用于计算小数位
    132.  
    133.     int size1=str1.size(),size2=str2.size();
    134.     int i=size2-1;                                      //商第一位的位置
    135.     string temp=str1.substr(0,i);                       //从str1上取size2-1个字符
    136.     for(i;i
    137.         temp+=str1[i];                                  //从后边拿出一位，预先处理可以防止结尾处越界
    138.         int cnt=0;                                      //当前位的商，也就是temp中包含了多少个str2，使用减法                                          //如果temp不为0，则计算商
    139.         while(Lower(str2,temp)||temp==str2){            //如果当前位商不为0，则计算商
    140.             temp=Sub(temp,str2);
    141.             cnt++;
    142.         }
    143.         if(temp=="0") temp.clear();                     //如果某次计算结果为0，则清空，避免0的堆积,比如111000 111
    144.         ans.push_back('0'+cnt);                         //保存商
    145.     }
    146.     i=0;
    147.     while(ans[i]=='0') i++;
    148.     ans=ans.substr(i,ans.size()-i);                     //去除前导0
    149.     if(point){                                          //如果是纯小数,补足6位并添加小数点
    150.         int len=6-ans.size();
    151.         ans="0."+string(len,'0')+ans;
    152.     }
    153.     else ans.insert((ans.end()-6),'.');                 //如果不是小数，则只需要插入小数点       
    154.     if(negative) ans="-"+ans;                           //最后一步骤，如果是负数带上负号
    155.     return ans;
    156. }
    157. bool Lower(string str1, string str2){                   //长度长的一定大（这里假设除了0以外，都没有前导0），长度相等则字典序小的数字更小
    158.     return str1.size()size()||(str1.size()==str2.size()&&str1
    159. }
    160. bool CheckZero(const string &str){      //检查是否等于0
    161.     int size=str.size();                //如果全是0则为0，这里假设不会有带符号的+00000或者-00000作为输入
    162.     for(int i=0;i
    163.         if(str[i]!='0') return false;
    164.     return true;
    165. }
    166. bool CheckNegative(const string &str){  //检查是否为负数
    167.     return str[0]=='-';
    168. }
    169. void ShowMenu(){
    170.     cout<<"请选择要进行的大数运算：\n"
    171.         <<"a) 加法          b) 减法\n"
    172.         <<"c) 乘法          d) 除法\n"
    173.         <<"q) 退出\n"
    174.         <<"请输入你的选择： ";
    175. }
    176. void ShowMenu(char choice){
    177.     cout<<"请输入要计算的两个数字";
    178.     switch(choice){
    179.         case 'a':cout<<"（仅支持非负整数加法计算）: "<break;
    180.         case 'b':cout<<"（仅支持非负整数减法计算）: "<break;
    181.         case 'c':cout<<"（仅支持整数乘法计算）: "<break;
    182.         case 'd':cout<<"（仅支持整数除法计算，计算结果保留6位小数，之后的直接舍弃）: "<break;
    183.     }
    184. }

    附录、进一步学习了解

    https://blog.csdn.net/weixin_44668898/article/details/96763177

    https://blog.csdn.net/wyqxii/article/details/131965735

  • 相关阅读:
    胖小酱为什么天上会打雷？
    【Vue十二】--- 指令
    力扣刷题-哈希表-三数之和
    【DR_CAN-MPC学习笔记】3.一个详细的建模例子
    FSDP(Fully Sharded Data Parallel)
    vue3按需引入 vite-plugin-style-import 2.0版本报错（解决办法）
    【力扣练习】找一个字符串中不含有重复字符的最长字串的长度
    [激光原理与应用-34]：《光电检测技术-1》- 光学测量基础 - 光电检测、光学测量、作用、应用、发展趋势
    VS2019编译配置Easy3D
    VirtualBox网络连接方式学习笔记
  • 原文地址：https://blog.csdn.net/cnds123/article/details/132858897