高精度-优快云博客

本文链接：https://blog.youkuaiyun.com/ozhuzhenfeng1993/article/details/9400729

本文介绍了一种使用数组模拟高精度运算的方法，并详细展示了如何通过该方法计算大数阶乘的精确值。此外，还提供了高精度整数类bign的设计与实现，包括赋值、输入输出等关键功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1，阶乘的准确值
为了方便起见，我们F[0]保存个位，f[1]保存十位，f[2]保存百位·······，只需模拟手算即可完成n！。在输出时忽略前导0.
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
const int maxn=3000;
int f[maxn];
int main()
{
	int i, j, n;
	cin>>n;
	memset(f, 0, sizeof(f));
	f[0]=1;
	for(i=2; i<=n; i++)
	{
		int c=0; 
		for(j=0; j<maxn; j++)
		{
			int s=f[j]*i+c;
			f[j]=s%10;
			c=s/10;
		}
	}
//忽略前导0 
	for(j=maxn-1; j>=0; j--)
	{
		if(f[j])
			break;
	}
	for(i=j; i>=0; i--)
		cout<<f[i];

	cout<<endl;
	return 0;
}
2，高精度运算类bign
设计一个结构体bign来储存高精度非负整数
const int maxn =1000;
struct bign
{
	int len, s[maxn];
	bign()
	{
		memset(s, 0, sizeof(s));
		len=1;
	}
}；
然后是重新定义赋值运算符：
const int maxn =1000;
struct bign
{
	int len, s[maxn];
	bign()
	{
		memset(s, 0, sizeof(s));
		len=1;
	}
	bign operator = (const char* num)
	{
		len=strlen(num);
		for(int i=0; i<len; i++)
			s[i]=num[len-i-1]-'0';
		return *this;
	｝
}；


这样就可以用x=“1234567898765432123456789”这样的方式给x赋值了，它会把这个字符串转化为逆序数组加长度的内部表示方法。为了让其也支持x=1234，这样的赋值方式，
另外一种赋值运算是：
const int maxn =1000;
struct bign
{
	int len, s[maxn];
	bign()
	{
		memset(s, 0, sizeof(s));
		len=1;
	}
	bign operator = (const char* num)
	{
		len=strlen(num);
		for(int i=0; i<len; i++)
			s[i]=num[len-i-1]-'0';
		return *this;
	｝
	
	bign operator = (int num)
	{
		char s[maxn];
		sprintf(s, "%d", num);
		*this=s;
		return *this;
	｝
}；


为了让代码支持初始化操作，还需要增加两个函数：
const int maxn =1000;
struct bign
{
	int len, s[maxn];
	bign()
	{
		memset(s, 0, sizeof(s));
		len=1;
	}
	bign(int num)
	{
		*this=num;
	}
	bign(const char* num)
	{
		*this=num;
	}
	bign operator = (const char* num)
	{
		len=strlen(num);
		for(int i=0; i<len; i++)
			s[i]=num[len-i-1]-'0';
		return *this;
	｝
	
	bign operator = (int num)
	{
		char s[maxn];
		sprintf(s, "%d", num);
		*this=s;
		return *this;
	｝
}；


然后提供一个函数将其转化为字符串：
const int maxn =1000;
struct bign
{
	int len, s[maxn];
	bign()
	{
		memset(s, 0, sizeof(s));
		len=1;
	}
	bign(int num)
	{
		*this=num;
	}
	bign(const char* num)
	{
		*this=num;
	}
	string str() const
	{
		string res="";
		for(int i=0; i<len; i++)
			res=(char)(s[i]+'0')+res;
		if(res=="")	res=0;
		return res;
	}
	bign operator = (const char* num)
	{
		len=strlen(num);
		for(int i=0; i<len; i++)
			s[i]=num[len-i-1]-'0';
		return *this;
	｝
	
	bign operator = (int num)
	{
		char s[maxn];
		sprintf(s, "%d", num);
		*this=s;
		return *this;
	｝
}；


接下来重载<<和>>符：
const int maxn =1000;
struct bign
{
	int len, s[maxn];
	bign()
	{
		memset(s, 0, sizeof(s));
		len=1;
	}
	bign(int num)
	{
		*this=num;
	}
	bign(const char* num)
	{
		*this=num;
	}
	string str() const
	{
		string res="";
		for(int i=0; i<len; i++)
			res=(char)(s[i]+'0')+res;
		if(res=="")	res=0;
		return res;
	}
	bign operator = (const char* num)
	{
		len=strlen(num);
		for(int i=0; i<len; i++)
			s[i]=num[len-i-1]-'0';
		return *this;
	｝
	
	bign operator = (int num)
	{
		char s[maxn];
		sprintf(s, "%d", num);
		*this=s;
		return *this;
	｝
}；
istream& operator >> (istream &in, bign& x)
{
	string s;
	in>>s;
	x=s.c_str();
	return in;
}
ostream& optreator << (ostream &out, const bign& x)
{
	out<<x.str();
	return out;
}

以此类推可以重载bign的常用运算符