CCF-GESP5级考试——(C++)数组模拟高精度加法、减法、乘法、除法-CSDN博客

本文链接：https://blog.csdn.net/qq_51831335/article/details/141498441

在C++中，通常使用基本的整数类型（如`int`、`long`等）和浮点数类型（如`float`、`double`等）来进行加减乘除运算。这些基本类型在表示数字时有一定的范围和精度限制。

int类型通常是32位有符号整数，可以表示的范围是[ $-2^{31}$ , $-2^{31}-1$ ]。这是因为int类型使用一个符号位来表示正负号，剩下的31位用来表示数值，其中一位用来表示0。因此当我们进行下面这样的加法运算便会导致溢出，得到负数👇

int num1 = 2147483647; // 最大的32位有符号整数
int num2 = 2;
int sum = num1 + num2;
cout << "整数相加结果: " << sum << endl; // 结果会溢出，输出为负数

浮点数float也是一样的道理，浮点数通常使用IEEE 754标准进行表示，其中float类型通常是单精度浮点数，占用32位，包括1位符号位、8位指数位和23位尾数位。这意味着float类型可以表示大约6到9位的十进制数。超出这个范围的数字可能会出现舍入误差或精度丢失。

指数部分的存在是为了表示浮点数的数量级，即数值的大小。通过指数部分，可以表示非常大或非常小的数，从而扩大了浮点数的表示范围。指数部分允许浮点数进行数量级的调整，使得浮点数可以表示很大范围的数值。
尾数部分则用来表示浮点数的精度，即小数部分。23位的尾数部分可以提供大约6到9位的十进制精度。这意味着浮点数可以表示小数点后6到9位的数字，具有一定的精度。

下面是一个简单的示例，展示了float类型表示小数后几位的情况：

#include <iostream>
#include <iomanip>
using namespace std;
int main() {
    float num = 3.14159265358979323846f; // π的近似值
    cout << setprecision(10) << num << endl; // 设置输出精度为10位
    return 0;
}

综上所述，在处理非常大或非常小的数字时C++自带的加减乘除都可能会出现溢出或精度丢失的问题。为了解决这些问题，需要使用高精度算法来进行精确的计算。

👑 1 高精度加法

1.1 思路 🎈

模拟手动加法计算即可。例如计算：567 + 28

先个位相加： 7 + 8 = 15，所以结果的个位是5，向十位进 1
再十位相加： 6 + 2 + 1（进位）= 9，所以十位是 9，向百位进 0
再百位相加： 5 + 0 = 5，所以结果的百位是 5

综上，计算结果为 595

1.2 算法🎈

创建 a, b 两个字符串存储输入，假设令a = 567, b = 28，给出代码求解步骤：

将两个数分别倒序存放在 A， B 两个整数数组中。 A = [7, 6, 5], B = [8, 2]（为什么要倒序？这是计算顺序）
新建整数数组 C 保存结果，整型变量 t 保存进位，初始 t = 0。（可能出现相加>=10，因此需要记录进位）
将每个位置上对应的数字相加，得到该位置的数字和是否进位。（实际计算）
例如对个位计算： A[0] + B[0] = 7 + 8 = 15, 结果个位上是 5，进位是 1. 所以 C[0] = 5, 进位 t = 1。（C[0]=5个位数相加后为5，下一次需要进位，即除了相加所得值还需加上1，故t=1）
最后把结果数组 C 中就保存了计算倒序结果，倒序输出就是答案。（现在是计算顺序，倒序输出才是数字的正常格式，即个位在最右边，但却是第一个计算的。这很符合”栈“先进后出。）

1.3 代码🥒

#include <iostream>
#include <vector>
using namespace std;
vector<int> add(vector<int> &A, vector<int> &B)
{
    //为了方便计算，让A中保存较长的数字， B中保存较短的数字
    if (A.size() < B.size()) return add(B, A);
    //保存结果的数组
    vector<int> C;
    //进位，开始时是0
    int t = 0;
    //依次计算每一位
    for (int i = 0; i < A.size(); i ++ )
    {
        t += A[i];//加上 A 的第 i 位上的数字
        if (i < B.size()) t += B[i];//加上 B 的第 i 位上的数字
        C.push_back(t % 10); //C 中放入结果
        t /= 10;//t 更新成进位
    }
    //最后如果进位上有数，放进结果数组
    if (t) C.push_back(t);
    return C;//返回结果
}

int main()
{
    string a, b;//以字符串形式保存输入的两个整数
    vector<int> A, B;//保存两个整数的数组
    cin >> a >> b;//接收输入
    for (int i = a.size() - 1; i >= 0; i -- ) A.push_back(a[i] - '0');//倒序存储第一个数
    for (int i = b.size() - 1; i >= 0; i -- ) B.push_back(b[i] - '0');//倒序存储第二个数
    auto C = add(A, B);//调用加和函数
    for (int i = C.size() - 1; i >= 0; i -- ) cout << C[i];//倒序输出C中的数字
    cout << endl;
    return 0;
}

👑 2 高精度减法

2.1 思路🎈

和高精度加法差不多，值得注意的是

减法的借位处理
相减为负数的处理
前导0的处理

2.2 算法🎈

2.3 代码🎈

// 给定两个正整数

#include <iostream>
#include <vector>

using namespace std;

bool cmp(vector<int>& A, vector<int> &B)
{
    if(A.size() != B.size()) return A.size() > B.size();  //直接ruturn 了就不用else

    for(int i = A.size(); i >= 0; i--)
        if(A[i] != B[i])
            return A[i] > B[i];

    return true;
}

vector <int> sub(vector<int>& A, vector<int> &B)
{
    vector<int> C;
    int t = 0;
    for(int i = 0; i < A.size(); i++)
    {
        t = A[i] - t;
        if(i < B.size()) t -= B[i];
        C.push_back((t + 10) % 10 ); // 合而为1
        if(t < 0)  t = 1;
        else t = 0;

    }

    while(C.size() > 1 && C.back() == 0) C.pop_back();  //去掉前导0

    return C;
}

int main()
{
    string a ,b;
    vector<int> A, B;

    cin >> a >> b ;

    for(int i = a.size() - 1; i >= 0; i--) A.push_back(a[i] - '0');
    for(int i = b.size() - 1; i >= 0; i--) B.push_back(b[i] - '0');

    if (cmp(A,B)) 
    {
        auto C = sub(A, B);
        for(int i = C.size() - 1; i >= 0; i--) printf("%d", C[i]);
        return 0;
    }
    else
    {
        auto C = sub(B, A);
        printf("-");
        for(int i = C.size() - 1; i >= 0; i--) printf("%d", C[i]);
        return 0;
    }


}

👑 高精度乘法

高精度 X 低精度

#include <iostream>
#include <vector>

using namespace std;

vector <int> mul(vector <int> & A, int b) {
    vector <int> C;

    int t = 0;
    for (int i = 0; i < A.size(); i ++) {
        t += A[i] * b;       // t + A[i] * b = 7218
        C.push_back(t % 10); // 只取个位 8
        t /= 10;             // 721 看作 进位
    }

    while (t) {            // 处理最后剩余的 t
        C.push_back(t % 10);
        t /= 10;
    }

    while (C.size() > 1 && C.back() == 0) C.pop_back();

    return C;
}

int main() {
    string a;
    int b;
    cin >> a >> b;

    vector <int> A;
    for (int i = a.size() - 1; i >= 0; i --) A.push_back(a[i] - '0');

    auto C = mul(A, b);

    for (int i = C.size() - 1; i >= 0; i --) {
        cout << C[i];
    }

    return 0;
}

高精度 X高低精度

#include <iostream>
#include <vector>

using namespace std;

vector<int> mul(vector<int> &A, vector<int> &B) {
    vector<int> C(A.size() + B.size() + 7, 0); // 初始化为 0，C的size可以大一点

    for (int i = 0; i < A.size(); i++)
        for (int j = 0; j < B.size(); j++)
            C[i + j] += A[i] * B[j];

    int t = 0;
    for (int i = 0; i < C.size(); i++) { // i = C.size() - 1时 t 一定小于 10
        t += C[i];
        C[i] = t % 10;
        t /= 10;
    }

    while (C.size() > 1 && C.back() == 0) C.pop_back(); // 必须要去前导 0，因为最高位很可能是 0
    return C;
}

int main() {
    string a, b;
    cin >> a >> b; // a = "1222323", b = "2323423423"

    vector<int> A, B;
    for (int i = a.size() - 1; i >= 0; i--)
        A.push_back(a[i] - '0');
    for (int i = b.size() - 1; i >= 0; i--)
        B.push_back(b[i] - '0');

    auto C = mul(A, B);

    for (int i = C.size() - 1; i >= 0; i--)
        cout << C[i];

    return 0;
}

👑 高精度除法

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
//int r=0;
vector<int> div(vector<int> &A,int B,int &r){//r传入r的地址，便于直接对余数r进行修改
    vector<int> C;
    for(int i=0;i<A.size();i++){//对A从最高位开始处理
        r=r*10+A[i];//将上次的余数*10在加上当前位的数字，便是该位需要除的被除数
        C.push_back(r/B);//所得即为商在这一位的数字
        r=r%B;
    }
    //由于在除法运算中，高位到低位运算，因此C的前导零都在vector的前面而不是尾部，vector只有删除最后一个数字pop_back是常数复杂度，而对于删除第一位没有相应的库函数可以使用，而且删除第一位，其余位也要前移，
    //因此我们将C翻转，这样0就位于数组尾部，可以使用pop函数删除前导0
    reverse(C.begin(),C.end());
    while(C.size()>1&&C.back()==0) C.pop_back();
    return C;
}
int main(){
    string a;
    int B,r=0; //代表余数
    cin>>a>>B;
    vector<int> A;
    for(int i=0;i<a.size();i++) A.push_back(a[i]-'0');//注意这次的A是由高为传输至低位，由于在除法的手算过程中，发现从高位进行处理
    //for(int i=0;i<A.size();i++) cout<<A[i];
    //cout<<B;
    auto C = div(A,B,r);
    for(int i=C.size()-1;i>=0;i--) cout<<C[i];//将C从最高位传给最低位
    cout<<endl<<r;//输出余数
    cout<<endl;
    return 0;
}