【C++】高精度运算（未完）

Azusa_10

已于 2023-10-21 21:52:15 修改

阅读量105

点赞数

文章标签： c++ cocoa 开发语言

于 2023-10-05 17:10:32 首次发布

本文链接：https://blog.csdn.net/2301_76208098/article/details/133581489

版权

【C++】高精度运算

1. 高精度加法

原理：

由于c++不能进行位数过高的数据运算，所以要通过模拟数组来进行运算，首先是加法。通过char或string型数据输入字符来模拟数字的输入，数组下表对应的元素应当是处于同一位置的数字，下标相同的两个元素相加表示的既是结果。

需要注意的是：

输入的是字符串，但是相加的时候必须要转换为数字，所以将字符型减去‘0’（0的字符）即可得到int型的数字。
输入的数组从最高位开始输入，不利于计算，应该如下：
a[i] = 2 0 2 3 （四位数）

b[i] = 1 1 4 （三位数）

直接同数组位相加的话：↓

result[i] = 3 1 6 3 与正确结果： 2 1 3 7 相差甚远

倒叙相加相加的话：↓

a1[i] = 3 2 0 2

b1[i] = 4 1 1 相加↓

result[i] = 7 3 1 2 （倒叙输出正好与正确答案相符）
倒序输出答案。这里有一个小细节，如果最高位大于9，则需要多输出一个result[i]

代码部分：

核心代码：

//核心代码（相加、进位）
	for(int i = 0; i < max(strlen(a1), strlen(b1)); i++)
	{ 
		result[i] += (a[i] + b[i]); 	//按位相加 
		result[i + 1] = result[i] / 10; //进位 
		result[i] %= 10; 	    		//本位mod10 
	}

完整代码：

#include <iostream>
#include <cstring>
using namespace std;
const int N = 2010; 
char a1[N], b1[N];//分表表示字符串类型的两个加数 
int a[N], b[N], result[N];//a[],b[]表示int类型的两个加数，方便运算， 
int main()
{
	cin >> a1 >> b1;
	//倒序存储，将a1的各个数存入a数组中
	for(int i = 0; i < strlen(a1); i++)
	{
		a[strlen(a1) - 1 - i] = a1[i] - '0';	
	}
    //同理可得
	for(int i = 0; i < strlen(b1); i++)
	{
		b[strlen(b1) - 1 - i] = b1[i] - '0';	
	}
	//核心代码 
	for(int i = 0; i < max(strlen(a1), strlen(b1)); i++)
	{ 
		result[i] += (a[i] + b[i]); 	//按位相加，先将两位相加，后续在处理进位和取余。注意是+=，因为之前可能有进位的情况发生
		result[i + 1] = result[i] / 10; //进位，将刚刚相加的result[i]的十位存储进来，前面数组是0，用=即可
		result[i] %= 10; 				//本位mod10，一个数组位仅可存一位数，进位已处理完毕，所以对10取余即可
	}
	//看看加完之后的结果用不用进位
	int add = 0; 
	if(result[max(strlen(a1), strlen(b1))] != 0)
	{
		add = 1;//原来的数位最大可能没有相加后的大，要确保多的位数也要输出
	}
	//倒序输出 
	for(int i = max(strlen(a1), strlen(b1)) + add - 1; i >= 0; i--)//数组是从0开始存的，所以需要-1
	{
		cout << result[i];
	}
	return 0;
}

2.高精度减法

1. 原理：

同加法相似，同样需要倒叙存储，顺叙相加，区别在于需要判断是否为负数。

2. 思路：

定义存储数组。
被减数和减数确认。由于减法可能出现负数。
读入数据到数组中。注意：保证被减数大于减数；倒序存放，也就是个位放在数组下标为 0 的地方。
从个位开始模拟竖式减法的过程，完成整个减法。
删除前导 0 。所谓前导零，就是出现类似这样数据 01234，这个 0 实际是不需要的。
输出减法的结果。倒序输出减法的结果数组 C，因为我们的个位是存储在下标为 0 的地方。

3. 技术细节说明：

1. 被减数和减数确认

由于减法可能出现负数，如 3-5=-2，我们在计算的时候，实际是使用 5-3=2，最后在结果前面添加负号。如果出现被减数小于减数的情况，要将两者颠倒。

cin >> s1 >> s2;
int lena = strlen(s1);//获取字符串长度
int lenb = strlen(s2);
//以下为判断被减数和减数确认，判断最终的结果符号
if ((lena < lenb) || (lena == lenb) && strcmp(s1, s2) < 0)//如果被减数小于减数或长度相等时被减数小于减数时，就需要输出"-"负号
{
    printf("-");
    //交换数据
    strcpy(temp, s1);//将s1的值传给temp
    strcpy(s1, s2);
    strcpy(s2, temp);
    //更新长度数据
    lena = strlen(s1);
    lenb = strlen(s2);
}

补充：

strcmp是判断s1与s2在ASCII码中哪个更大

该函数返回值如下：

如果返回值`小于 0`，则表示 str1 `小于` str2。
如果返回值`大于 0`，则表示 str1 `大于` str2。
如果返回值`等于 0`，则表示 str1 `等于` str2。

2. 读入数据到数组

利用读入字符串的方法读入数据，再倒序写入到对应的数组中。这个部分代码如下：

//将字符串写入到数组A中
for (int i = 0; i < lena; i++)
{
    //倒序写入
    a[i] = s1[lena-i-1] - '0';
}
//同理可得
for (int i = 0; i < lenb; i++)
{
    b[i] = s2[lenb-i-1] - '0';
}

3. 模拟竖式减法

有个技术细节：如何判断发生借位。这个部分代码如下：

//模拟竖式减法
for (int i = 0; i < lena; i++)
{
    if (a[i] < b[i])//有借位
    {
        a[i+1]--;//前一位-1
        a[i] += 10;//此位+10
    }
    c[i] = a[i] - b[i];//相减
}

4. 删除前导零

因为减法运算可能会出现最高位为零，所以我们需要判断是否需要删除前导零。这个部分代码如下：

//删除前导零
for (int i = lena; i >= 0; i--)
{
    //因为我们是从索引 0 开始，所以最高位是保存在 len-1
    if (c[i] == 0 && lena > 1)
    //注意要有 lena>1 这个条件。考虑特殊情况，加法结果为 00，我们实际要输出 0。
        lena--;
    else break;//第一个不是零的最高位，结束删除
}

4. 完整代码：

#include <iostream>
#include <cstring>//有些函数需要cstring
const int N = 2023;
char s1[N], s2[N], temp[N];//定义s1、s2为被减数和减数，temp为中转数组
int a[N], b[N], c[N];//定义a、b数组来相减，结果存储在c中
using namespace std;
int main()
{
    cin >> s1 >> s2;
    int lena = strlen(s1);//获取字符串长度
    int lenb = strlen(s2);
    //以下为判断被减数和减数确认，判断最终的结果符号
    if ((lena < lenb) || (lena == lenb) && strcmp(s1, s2) < 0)//如果被减数小于减数或长度相等时被减数小于减数时，就需要输出"-"负号
    {
        printf("-");
        //交换数据
        strcpy(temp, s1);//将s1的值传给temp
        strcpy(s1, s2);
        strcpy(s2, temp);
        //更新长度数据
        lena = strlen(s1);
        lenb = strlen(s2);
    }
    //将字符串写入到数组A中
    for (int i = 0; i < lena; i++)
    {
        //倒序写入
        a[i] = s1[lena-i-1] - '0';
    }
    //同理可得
    for (int i = 0; i < lenb; i++)
    {
        b[i] = s2[lenb-i-1] - '0';
    }
    //模拟竖式减法
    for (int i = 0; i < lena; i++)
    {
        if (a[i] < b[i])//有借位
        {
            a[i+1]--;//前一位-1
            a[i] += 10;//此位+10
        }
        c[i] = a[i] - b[i];//相减
    }
    //删除前导零
    for (int i = lena; i >= 0; i--)
    {
        //因为我们是从索引 0 开始，所以最高位是保存在 len-1
        if (c[i] == 0 && lena > 1)
        //注意要有 lena>1 这个条件。考虑特殊情况，加法结果为 00，我们实际要输出 0。
            lena--;
        else break;//第一个不是零的最高位，结束删除
    }
    //逆序打印输出
    for (int i = lena-1; i >= 0; i--)
        printf("%d", c[i]);
    printf("\n");
    return 0;
}

3.高精度乘法

1.原理：

这里我们先姑且称 32145 为被乘数，16为乘数。经过模拟可以知道，实际上就是用乘数的每一位依次去乘被乘数，那么这样子就变成了高精度乘低精度的做法，相信你已经学会了！只不过每次 ans 开始相加的地方不同（相信你一定注意到了，乘数的第一位乘被乘数时，ans从ans[0] 开始，第二位乘被乘数时，ans从ans[1] 开始），这个问题的解决请看代码。

附上视频：

不知可否能使用……

2.源码：

#include <iostream>
#include <cstring>
const int N = 2023;
char s1[N], s2[N];
int a[N], b[N], result[N];
using namespace std;
int main()
{
    cin >> s1 >> s2;
    int lena = strlen(s1);
    int lenb = strlen(s2);

    for (int i = 0; i < lena; i++)
        a[i] = s1[lena-1-i] - '0';
    for (int i = 0; i < lenb; i++)
        b[i] = s2[lenb-1-i] - '0';//以上代码理解见上面高精度加、减。
    
    int carry = 0;//进位使用。
    int i = 0, j = 0;//i、j后面会用到，须定义在for外面。
    for (i = 0; i < lenb; i++)// 核心计算过程,外层循环为乘数, 内层循环为被乘数*int的高精乘低精算法 
        for (j = 0; j < lena || carry != 0; j++)//终止条件：j < lena || carry != 0；carry = 0即为没有进位，即乘法运算已完毕。
        {
            result[i+j] += a[j] * b[i] + carry;//注意ans的下标为 i+j ! a和 b下标对应它的循环变量
            carry = result[i+j] / 10;//进位处理
            result[i+j] %= 10;//本位mod10
        }
    
    int len = i + j;//获取结果位数，数组最后一个数字为 ans[i+j], 所以 i+j 即为ans长度
    while (result[len] == 0 && len > 0) // 去除前缀无用的 0
        len--;
    
    for (i = len; i >= 0; i--)//倒序输出 
        cout << result[i];
    
    return 0;
}