STL容器之Vector大数运算，实现任意位数的两个整数的加减法运算

柔光的暖阳◎ 2022-12-12 04:38 125阅读 0赞

在很多工程实践环节，需要进行大数运算，所谓大数，指的是无法使用常规数据类型来表达的数据，比如一个超过100位的整数。选用STL中合适的容器，实现任意位数的两个整数的加减法运算。

head.h部分：

#ifndef HEAD_H
    #define HEAD_H
    
    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    
    void bigPlus(const string &aStr, const string &bStr);
    void bigMinus(const string &aStr, const string &bStr);
    
    #endif // HEAD_H

--------------------

addition.cpp部分：

#include "head.h"
    
    void bigPlus(const string &aStr, const string &bStr)                    //加法
    { 
        vector<int> a;
        vector<int> b;
        for(int i=aStr.length()-1; i>=0; i--)                               //遍历动态数组aStr
            a.push_back(aStr[i] - '0');                                     //将数组aStr每个字符元素转换成整型存放到数组ａ中
        for(int i=bStr.length()-1; i>=0; i--)                               //遍历动态数组bStr
            b.push_back(bStr[i] - '0');                                     //将数组bStr每个字符元素转换成整型存放到数组ｂ中
    
        vector<int> sum;
        int carry = 0;
    
        int i;
        for(i=0; i<(int)a.size()&&i<(int)b.size(); i++)
        { 
            sum.push_back((a[i]+b[i]+carry) % 10);                          //a+b+进位，再求余，余数存放到sum里
            carry  = (a[i]+b[i]+carry) / 10;                                //a+b+进位，再除10,商为进位值
        }
    
        if(a.size() == b.size() && carry == 1)                              //如果两数组长度相等，且有进位
            sum.push_back(1);                                               //sum数组＋１
    
        if(i < (int)a.size())                                               //如果ａ数组长度　> ｂ数组长度
        { 
            for(; i<(int)a.size(); i++)
            { 
                sum.push_back((a[i] + carry) % 10);                         //将进位值＋a[i]的余数存放到sum里面
                carry  = (a[i] + carry) / 10;                               //计算进位值
            }
        }
        if(i < (int)b.size())                                               //如果ａ数组长度　< ｂ数组长度
        { 
            for(; i<(int)b.size(); i++)
            { 
                sum.push_back((b[i] + carry) % 10);                         //将进位值＋b[i]的余数存放到sum里面
                carry  = (b[i] + carry) / 10;                               //计算进位值
            }
        }
    
        if(carry == 1)
            sum.push_back(1);
    
        cout << aStr << " + " << bStr << " = ";                             //输出格式
        for(vector<int>::reverse_iterator rit = sum.rbegin();
            rit != sum.rend(); rit++)
        { 
            cout << *rit;
        }
        cout << endl;
    }
    
    
    void bigMinus(const string &aStr, const string &bStr)                   //减法
    { 
        vector<int> a;
        vector<int> b;
    
        vector<int> max;
        vector<int> min;
    
        for(int i=aStr.length()-1; i>=0; i--)                               //遍历动态数组aStr
            a.push_back(aStr[i] - '0');                                     //将数组aStr每个字符元素转换成整型存放到数组ａ中
        for(int i=bStr.length()-1; i>=0; i--)                               //遍历动态数组bStr
            b.push_back(bStr[i] - '0');                                     //将数组bStr每个字符元素转换成整型存放到数组ｂ中
    
        int flag = 1;
        while(a.size() == b.size())                                         //如果输入的数组长度相等
        { 
            if( a[a.size()-flag] == b[b.size()-flag])                       //数组对应元素大小相等
            { 
                flag ++;
            }
            else if( a[a.size()-flag] > b[b.size()-flag])                   //数组ａ对应元素　大于　数组b对应元素
            { 
                flag = 0;                                                   //flag置０
                break;                                                      //跳出循环
            }
            else                                                            //数组ａ对应元素　小于　数组b对应元素
            { 
                flag = 1;                                                   //flag置１
                break;                                                      //跳出循环
            }
        }
    
        if(a.size() > b.size() || (a.size() == b.size() && flag == 0))      //ａ数组长度 > ｂ数组长度,或者　数组ａ对应元素　大于　数组b对应元素
        { 
    
            for(int i=0; i< (int)a.size(); i++)                             //遍历动态数组a
                max.push_back(a[i]);                                        //将数组a每个元素存放到数组max中
            for(int i=0; i< (int)b.size(); i++)                             //遍历动态数组b
                min.push_back(b[i]);                                        //将数组b每个元素存放到数组min中
        }
    
        else if(a.size() < b.size() || (a.size() == b.size() && flag == 1)) //ａ数组长度 > ｂ数组长度,或者　数组ａ对应元素　小于　数组b对应元素
        { 
            for(int i=0; i< (int)a.size(); i++)                             //遍历动态数组a
                min.push_back(a[i]);                                        //将数组a每个元素存放到数组min中
            for(int i=0; i< (int)b.size(); i++)                             //遍历动态数组b
                max.push_back(b[i]);                                        //将数组b每个元素存放到数组max中
        }
    
    
        vector<int> sum;
        int carry = 0;                                                      //进位标志
        int i ;
    
        for(i = 0; i < (int)max.size() && i < (int)min.size(); i++)         //数组位数相匹配时，遍历相减
        { 
            if(max[i] < min[i])                                             //max[i]的值　< min[i]的值
            { 
                sum.push_back((max[i]+ 10 - min[i]) - carry);               //max[i]的值+借位10 - min[i] - 前(右)一位的借位
                carry = 1;                                                  //向后（左）一位借位
            }
    
            if(max[i] > min[i])                                             //max[i]的值　> min[i]的值
            { 
                sum.push_back((max[i]- min[i] - carry));                    //max[i] - min[i] - 前(右)一位的借位
                carry = 0;                                                  //不用借位
            }
    
            if(max[i] == min[i] && carry == 0)                              //max[i]的值　== min[i]的值,前面（右边）没有借位
            { 
                sum.push_back((max[i]- min[i]));                            //直接相减
                carry = 0;
            }
    
            if(max[i] == min[i] && carry == 1)                              //max[i]的值　== min[i]的值,前面（右边）有借位
            { 
                sum.push_back((max[i]+ 10 - min[i] - carry));               //相减，还要减去前面的借位
                carry = 1;                                                  //向后（左边）借位
            }
        }
    
        if(max.size() == min.size() )                                       //情况①：两动态数组大小相等
        { 
            cout << aStr << " - " << bStr << " = ";                         //输出格式
    
            if(flag == 1)                                                   //max小于min(负数),否则为正数
            { 
                cout << "-";
            }
    
            for(vector<int>::reverse_iterator rit = sum.rbegin();           //遍历sum数组，输出差值
                rit != sum.rend(); rit++)
            { 
                cout << *rit;
            }
            cout << endl;
        }
    
        if(i < (int)max.size())                                            //数组max大小　> 数组min的大小
        { 
            for(; i<(int)max.size(); i++)
            { 
                if(max[i] == 0 && carry == 1)                              //如果max[i] == 0，且前面有借位
                { 
                    sum.push_back(max[i] + 10 -carry);                     //max向后借位10-前面的借位
                    carry = 1;                                             //继续向后面借位
                }
    
    
                else if(max[i] != 0 && carry == 1)                          //如果max[i] ！＝ 0，且前面有借位
                { 
    
                    sum.push_back(max[i] - carry);                          //max[i]直接减去前面的借位
                    carry  = 0;                                             //借位置0
                }
    
                else if(carry == 0)                                         //前面没有借位
                { 
                    sum.push_back(max[i]);                                  //直接赋值
                }
            }
    
            cout << aStr << " - " << bStr << " = ";                         //输出格式
            if(a.size() < b.size())                                         //如果第一个数组长度＞第二个数组长度
            { 
                cout << "-";                                                //打印　﹣　号
            }
    
            for(vector<int>::reverse_iterator rit = sum.rbegin();           //遍历sum数组，输出max - min的值
                rit != sum.rend(); rit++)
            { 
                cout << *rit;
            }
            cout << endl;
        }
    }

--------------------

main.cpp部分：

#include <iostream>
    #include "head.h"
    
    int main()
    { 
        string aStr;
        string bStr;
    
        while(1)
        { 
            aStr.clear();
            bStr.clear();
    
            cin >> aStr >> bStr;                    //输入两个大数
    
            bigPlus(aStr, bStr);                    //加法
            bigMinus(aStr, bStr);                   //减法
            cout << endl;
        }
    
        return 0;
    }

--------------------

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc5MzE4MQ_size_16_color_FFFFFF_t_70_pic_center]  
注意注意！！！！！  
本代码存在三个bug，经过某博友的测试修改，已解决:  
[用vector实现任意长度的非负整数加减运算（基于C++/STL）][vector_C_STL]  
大家可以跳转查看学习！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc5MzE4MQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/6c4e236db66e4c2597f7911cd30cc847.png
[vector_C_STL]: https://blog.csdn.net/weixin_49263146/article/details/110872620