【C++】【算法】高精度加减乘除

原创最新推荐文章于 2026-08-04 16:02:03 发布 1.3k 阅读 AI写同款

鼓浪屿Estelle

307粉丝11篇原创

关注

C++高精度算法————减法 高精度减法（High Precision Subtraction）是一种用于处理超过原生数据类型范围的大整数或高精度小数的计算技术。与高精度加法类似，高精度减法也需要使用自定义的数据结构和算法来进行计算。在函数内部，我们首先判断 num1 是否大于等于 num2，如果不满足则抛出异常。然后，我们通过逐位减法，处理借位来得到结果。需要注意的是，上述的代码示例仅展示了一种简单的实现方式，对于大规模的高精度计算，可能需要考虑优化算法或使用专门的高精度计算库。函数进行高精度减法，并打印结果。函数，接受两个大整数。阅读详情

AI摘要

本文介绍了C++中高精度算法的实现。由于C++内置类型数据存储范围有限，无法进行超出范围的高精度运算，因此借助string和数组实现。详细阐述了高精度加法、减法、乘法和除法的算法思路、代码实现及特殊情况处理，还提及了高精度算法的应用场景。

0 引言

在用C++写代码时，为了解决各种问题，我们会经常使用到加减乘除，我们对加减乘除运算也再熟悉不过。

但是，C++作为一门强类型语言，不管是使用short，int，亦或是long long，对数据存储范围都是有限的；

类型	大小	范围
short	2字节	-32768 ~ 32767
int	4字节	-2147483648~2147483647
long long	8字节	-2^63 ~ 2^63-1

当我们加减乘除要运算的数超过数据存储的范围时就无法进行运算，否则会导致越界造成严重的后果，那我们如果要进行这样高精度的计算，就需要使用到算法来对其进行实现，这种算法也可称为高精度算法，能实现高精度的运算；

1 高精度算法的介绍以及思路

当我们由于储存范围的原因无法使用C++的内置类型来进行运算时，我们可以借助STL库中的string来得到要计算的数据，再将string中的数据存入一个数组中，然后对数组中的每一位进行相应的运算，最后的结果存入数组中进行输出，我们的高精度算法也就完成了；

算法思路：

2 高精度加法

对于高精度加法，我们在处理完数据逆序存储于字符串中之后，对每一位进行加法运算，随后处理好进位，如下：

我们先定义一个全局变量，当做数组的大小，该全局变用户可根据需要自行改变，确保其能存下我们需要计算的数据：

const int N = 1e6 + 10;

再定义三个全局数组，分别存储两个要计算的数据和结果

int a[N], b[N], c[N];

然后定义三个全局变量表示三个数据的长度

int la, lb, lc;

先看第一步：将string中要计算的数据，逆序存储于数组中

cin得到要相加的两个数据，并使用string自带的size功能得出三个数据的长度la，lb，lc，结果的长度是两个要加的数据中大的数据的长度，如果说相加到最高位时还有进位，那么lc的长度应为la+1，这种特殊情况后面会单独处理：

string x, y;
cin >> x >> y;

la = x.size(), lb = y.size(), lc = max(la, lb);

如果要让字符串中的数据逆序存储于数组中，即a[0] = x[la - 1 - 0] ; a[1] = x[la -1 - 1] ; a[2] = x[la -1 - 2]; 可以发现，其下标的和正好为la - 1，因此，可以直接得出循环，实现逆序存储：

	for (int i = 0; i < la; ++i) a[i] = x[la - 1 - i] - '0';
	for (int i = 0; i < lb; ++i) b[i] = y[lb - 1 - i] - '0';

这里千万注意，字符串x，y中存储的是字符，当将其转移到数组中时应当减去字符0（‘ 0 ’）；

随后正常执行算法，然后输出，得到基本框架：

	add(a, b, c);

	for (int i = lc - 1; i >= 0; --i) cout << c[i];
	cout << endl;

	return 0;

下面来实现add算法：

对于数组中的两个数据相加，如下图所示，假设这两个数是1001和9099：

代码实现：

for (int i = 0; i < lc; ++i)
{
	c[i] += a[i] + b[i];
	c[i + 1] = c[i] / 10;
	c[i] %= 10;
}

注意：循环中第一个语句一定是c[i] += a[i] + b[i] ，因为还要算上进位，而第二步即得到进位，进位存储于下一个下标；c[i]本身的值去掉进位后即为c[i] % 10；

在这一步之后还需要更新lc的值，如果在加到最高位之后仍然有进位，那么lc的值应该加1，便于后序输出：

if (c[lc]) ++lc;

由此得到完整的add算法（参数可写可不写，因为是全局的）：

void add(int* a, int* b, int* c)
{
	for (int i = 0; i < lc; ++i)
	{
		c[i] += a[i] + b[i];
		c[i + 1] = c[i] / 10;
		c[i] %= 10;
	}

	if (c[lc]) ++lc;
}

完整代码如下：

#include <iostream>
#include <string>
using namespace std;

const int N = 1e6 + 10;

int a[N], b[N], c[N];

int la, lb, lc;

void add(int* a, int* b, int* c)
{
	for (int i = 0; i < lc; ++i)
	{
		c[i] += a[i] + b[i];
		c[i + 1] = c[i] / 10;
		c[i] %= 10;
	}

	if (c[lc]) ++lc;
}

int main()
{
	string x, y;
	cin >> x >> y;

	la = x.size(), lb = y.size(), lc = max(la, lb);
	for (int i = 0; i < la; ++i) a[i] = x[la - 1 - i] - '0';
	for (int i = 0; i < lb; ++i) b[i] = y[lb - 1 - i] - '0';

	add(a, b, c);

	for (int i = lc - 1; i >= 0; --i) cout << c[i];
	cout << endl;

	return 0;
}

测试：

3 高精度减法

高精度减法的基本框架和add基本一致，只是在算法的实现上有所区别，先写出其基本框架：

void del(int* a, int* b, int* c)
{
	
}

int main()
{
	string x, y;
	cin >> x >> y;

	la = x.size(), lb = y.size(), lc = max(la, lb);
	for (int i = 0; i < la; ++i) a[i] = x[la - 1 - i] - '0';
	for (int i = 0; i < lb; ++i) b[i] = y[lb - 1 - i] - '0';

	del(a, b, c);

	for (int i = lc - 1; i >= 0; --i) cout << c[i];
	cout << endl;

	return 0;
}

在此框架的基础上，在将string中的数据拷入数组之前，我们要求x > y，方便后序的减法操作，如果x < y的话，得到的结果应该是一个负数，要先输出符号，然后交换a, b的值；

因此，在进行del之前，应该先比较a，b的值，如下所示：

if (cmp(x, y))
{
	// x < y
	cout << '-';
	swap(x, y);
}

实现cmp：

x，y是两个字符串，我们知道两个字符串比较大小是按照字典序进行比较，也就是说，9会比666666这个字符串还要大，所以我们不能直接使用大小于号进行比较，我们应该先比较其长度，若长度，长度长的，这个数一定更大，长度若相同，则按照字典序进行比较：

bool cmp(string& x, string& y)
{
	if (x.size() != y.size()) return x.size() < y.size();
	return x < y;
}

若x比y小返回真；

再来对del进行实现，del和add有所不同的是，在del的for循环中，a[i]和b[i]要进行相减的运算，这个运算结果暂时存储于c[i]中，如果说c[i] 小于0，说明要向下一位进行借位，那么c[i+1]应当--，同时c[i] 应当 + 10，实现如下：

for (int i = 0; i < lc; ++i)
{
	c[i] += a[i] - b[i];
	if (c[i] < 0)
	{
		--c[i + 1];
		c[i] += 10;
	}
}

在进行了如上循环后，还有一种特殊情况，比如9999 - 9999，按照如上循环得到的c中的结果应该为0000，因为lc的长度没有改变，所以我们需要做进一步处理，在有效数字之前不能存在0，即要去掉前导0，但结果若为0000，还需保留一个0，所以lc的长度至少要为1，如下：

while (lc > 1 && c[lc - 1] == 0) --lc;

完整代码如下：

#include <iostream>
#include <string>
using namespace std;

const int N = 1e6 + 10;

int a[N], b[N], c[N];

int la, lb, lc;

void del(int* a, int* b, int* c)
{
	for (int i = 0; i < lc; ++i)
	{
		c[i] += a[i] - b[i];
		if (c[i] < 0)
		{
			--c[i + 1];
			c[i] += 10;
		}
	}

	while (lc > 1 && c[lc - 1] == 0) --lc;
}

bool cmp(string& x, string& y)
{
	if (x.size() != y.size()) return x.size() < y.size();
	return x < y;
}

int main()
{
	string x, y;
	cin >> x >> y;

	if (cmp(x, y))
	{
		// a < b
		cout << '-';
		swap(x, y);
	}

	la = x.size(), lb = y.size(), lc = max(la, lb);
	for (int i = 0; i < la; ++i) a[i] = x[la - 1 - i] - '0';
	for (int i = 0; i < lb; ++i) b[i] = y[lb - 1 - i] - '0';

	

	del(a, b, c);

	for (int i = lc - 1; i >= 0; --i) cout << c[i];
	cout << endl;

	return 0;
}

测试：

4 高精度乘法

高精度乘法的基本框架也是和add基本一致，只是在算法的实现上有所区别，先写出其基本框架：

void mul(int* a, int* b, int* c)
{

}

int main()
{
	string x, y;
	cin >> x >> y;

	la = x.size(), lb = y.size(), lc = la + lb;
	for (int i = 0; i < la; ++i) a[i] = x[la - 1 - i] - '0';
	for (int i = 0; i < lb; ++i) b[i] = y[lb - 1 - i] - '0';

	mul(a, b, c);

	for (int i = lc - 1; i >= 0; --i) cout << c[i];
	cout << endl;

	return 0;
}

这里需要注意的是，lc的大小不再是la和lb较大的那个值，而是la+lb，因为对于两个数相乘，积的长度不会超过两个数的位数之和；

对于高精度乘法，对两个数列竖式计算乘法，如果向我们一般列竖式的做法，整个过程会变得非常麻烦，我们应该采用另一种更简单的方法来列竖式计算———不进制列竖式乘法，即在列竖式时直接写出相乘的结果，在相加后再统一进制，对123×456这两个数进行演示：

对于a，b和c，有这样的规律 -> a[ i ] * b[ j ]的值刚好是c[ i + j ]处值的叠加，因此，只需要两个for循环就能初步完成这个算法：

for (int i = 0; i < la; ++i)
{
	for (int j = 0; j < lb; ++j)
	{
		c[i + j] += a[i] * b[j];
	}
}

此时得到的c中存储的数据还没有进位，所以我们要对其中的数据进行进位：

	// 进位
	for (int i = 0; i < lc; ++i)
	{
		c[i + 1] += c[i] / 10;
		c[i] %= 10;
	}

同样的，如果是0*9999，得到的结果会是00000，我们还是要处理前导0；

while (lc > 1 && c[lc - 1] == 0) --lc;

完整代码如下所示：

#include <iostream>
#include <string>
using namespace std;

const int N = 1e6 + 10;

int a[N], b[N], c[N];

int la, lb, lc;


void mul(int* a, int* b, int* c)
{
	for (int i = 0; i < la; ++i)
	{
		for (int j = 0; j < lb; ++j)
		{
			c[i + j] += a[i] * b[j];
		}
	}

	// 进位
	for (int i = 0; i < lc; ++i)
	{
		c[i + 1] += c[i] / 10;
		c[i] %= 10;
	}

	while (lc > 1 && c[lc - 1] == 0) --lc;
}

int main()
{
	string x, y;
	cin >> x >> y;

	la = x.size(), lb = y.size(), lc = la + lb;
	for (int i = 0; i < la; ++i) a[i] = x[la - 1 - i] - '0';
	for (int i = 0; i < lb; ++i) b[i] = y[lb - 1 - i] - '0';

	mul(a, b, c);

	for (int i = lc - 1; i >= 0; --i) cout << c[i];
	cout << endl;

	return 0;
}

测试：

注意，此代码默认输入的两个数为正整数，如果需要计算负数，则在计算之前使用一下绝对值，根据同号为正异号为负的规则先输出符号再正常计算，比较简单，这里不多做演示；

5 高精度除法

对于高精度除法，我一般不研究高精度÷高精度，没什么意义，只需要研究高精度÷低精度足矣，所以其框架会和加减乘有所不同，这里只有被除数需要存储进一个数组，除数则不需要，除出来的结果可能很大，也需要存储进一个数组中；

先写出基本框架：

#include <iostream>
#include <string>
using namespace std;

const int N = 1e6 + 10;

int a[N], b, c[N];

int la, lc;

void sub(int* a, int b, int* c)
{
	
}

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

	la = x.size(), lc = la;
	for (int i = 0; i < la; ++i) a[i] = x[la - 1 - i] - '0';

	sub(a, b, c);

	for (int i = lc - 1; i >= 0; --i) cout << c[i];
	cout << endl;

	return 0;
}

被除数与结果的长度是一样的；

对于sub算法，我们要使用的方法是这样的，以1234 ÷ 45来示范：

sub初步实现如下：

为了使精度的容错更高，余数可能很大，所以我们将t定义为long long类型：

typedef long long LL;

void sub(int* a, int b, int* c)
{
	LL t = 0;
	for (int i = lc - 1; i >= 0; --i)
	{
		t = t * 10 + a[i];
		c[i] = t / b;
		t %= b;
	}
}

同样的，高精度除法也需要去除前导0：

	while (lc > 1 && c[lc - 1] == 0) --lc;

完整代码如下：

#include <iostream>
#include <string>
using namespace std;

const int N = 1e6 + 10;

int a[N], b, c[N];

int la, lc;

typedef long long LL;

void sub(int* a, int b, int* c)
{
	LL t = 0;
	for (int i = lc - 1; i >= 0; --i)
	{
		t = t * 10 + a[i];
		c[i] = t / b;
		t %= b;
	}

	while (lc > 1 && c[lc - 1] == 0) --lc;
}

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

	la = x.size(), lc = la;
	for (int i = 0; i < la; ++i) a[i] = x[la - 1 - i] - '0';

	sub(a, b, c);

	for (int i = lc - 1; i >= 0; --i) cout << c[i];
	cout << endl;

	return 0;
}

测试：