高精度运算（加减乘除乘方）

所谓高精度，就是大数的运算，这个大数可能是要远远超过现有数据类型的最大范围。如果我们想进行这样的运算，就要掌握计算的原理——竖式运算。`

加法

我们这里先简单考虑非负数的加法，竖式这么列对吧：

①存储

我们如何储存过长的数呢？可以用数组存储。怎么才能将各个数位上的数放到数组里面呢？这里，我们可以使用字符串。
我们使用逆序储存，这样会比较方便，后面可以在result数组中反向输出。

int a[241]=,b[241],result[242],l1=0,l2=0;
string c,d;
cin>>c>>d;
// 第一步读取整数
for(int i=c.size()-1;i>=0;i--){
	a[l1++]=c[i]-'0';
}
for(int i=d.size()-1;i>=0;i--){
	b[l2++]=d[i]-'0';
}

同时，这里l1表示第一个加数的长度，l2表示第二个加数的长度。

②模拟加法运算

接着，模拟运算：

	// 第二步加法计算
	int l=max(l1,l2)
	for(int i=0;i<l;i++){
		result[i]+=(a[i]+b[i])%10;
		result[i+1]+=(a[i]+b[i])/10;
	}

当我们进行加法运算时，每一位的结果是由两个部分组成的：当前位的数字和从低位“进”来的数字。例如，当我们计算23 + 18时，个位的结果是1，这个1就是从低位“进”来的，而2和3相加的结果是5，这个5就是当前位的数字。

在计算机中，当我们进行高精度计算时，通常会把每个数字拆分成多个位（如一个8位数字可以拆分成个位、十位、百位等），然后逐位进行加法运算。为了得到每个位的正确结果，我们需要考虑从低位“进”来的数字。

例如，如果我们有两个8位数字1234和5678，我们不能直接把它们相加，因为结果会超过8位。正确的做法是逐位进行加法运算：

1 + 6 = 7，没有进位，所以结果的个位就是7
2 + 7 = 9，进位1，所以结果的十位就是9 + 1 = 09
3 + 8 = 11，进位1，所以百位的结果是11 + 1 = 01
4 + 5 = 9，进位1，所以千位的结果是09 + 1 = 009

这样，我们就可以得到最终的结果：0097。

在上面的程序中，“进位”的思想体现在每次加法运算时都考虑了前一位的进位。通过这种方式，我们可以得到正确的高精度结果。

③反向输出：

for(int i=(x>y?x:y);i>=0;i--){
	cout<<result[i];
}

完整代码：

#include <iostream>
using namespace std;
int main(){
	// 高精度加法 240位内，调整数组大小可以扩大位数 
	int a[241]={},b[241]={},result[242]={},l1=0,l2=0;
	string c,d;
	cin>>c>>d;
	// 第一步读取整数
	for(int i=c.size()-1;i>=0;i--){
		a[l1++]=c[i]-'0';
	}
	for(int i=d.size()-1;i>=0;i--){
		b[l2++]=d[i]-'0';
	}
	int l=max(l1,l2); 
	// 第二步加法计算
	for(int i=0;i<l;i++){
		result[i]+=(a[i]+b[i])%10;
		result[i+1]+=(a[i]+b[i])/10;
	}
	for(int i=l;i>=0;i--){
		cout<<result[i];
	}
	return 0;
}

减法

不说什么了，与上同理

#include <iostream>
using namespace std;
int main(){
	string s1,s2;
	int a[241]={},b[241]={},result[241]={},k=0,t;
	cin>>s1>>s2;
	// 考虑几种特殊情况
	if(s1==s2){
		cout<<0;
		return 0;
	}
	if(s1.size()<s2.size()||s1.size()==s2.size()&&s1<s2){
		cout<<"-";
		swap(s1,s2);
	}
	// 存储数据
	for(int i=0;i<s1.size();i++){
		a[s1.size()-i-1]=s1[i]-'0';
	}
	for(int i=0;i<s2.size();i++){
		b[s2.size()-i-1]=s2[i]-'0';
	}
	// 模拟竖式的算法
	for(int i=0;i<(s1.size()>s2.size()?s1.size():s2.size());i++){
	    t=10-b[i]+a[i]+result[k++];
		if(t<10) result[k]--; // 退位，在后面一位减去1
		result[k-1]=t%10;
	}
	// 前面可能有0，从第一个不是0的数开始输出
	for(int i=k-1;i>=0;i--){
		if(result[i]>0){
			t=i; // 记录第一个不是0的数
			break;
		}
	}
	// 输出
	for(int i=t;i>=0;i--){
		cout<<result[i];
	}
	return 0;
}

放到草稿纸上，想想就明白了。

乘法

高精度乘单精度

我们用单精度去乘高精度的每一位，然后累加。

#include <iostream>
using namespace std;
int main(){
	// 高精度乘单精度（不超过10000）
    int a[251]={};
    string s1;
	int b;
    cin>>s1>>b;
    for(int i=0;i<s1.size();i++){
		a[i]=s1[s1.size()-i-1]-'0';
	}
	// 按位相乘
	for(int i=0;i<s1.size();i++){
		a[i]=a[i]*b;
	}
	// 处理进位
	for(int i=0;i<s1.size()+4;i++){
		if(a[i]>=10){
			a[i+1]+=a[i]/10;
			a[i]%=10;
		}
	}
	// 获取第一个不是0的数
	int point=0;
	for(int i=s1.size()+4;i>=0;i--){
		if(a[i]!=0){
			point=i;
			break;
		}
	}
	for(int i=point;i>=0;i--){
		cout<<a[i];
	}
	return 0;
}

高精度乘高精度

最难的地方，需要找找规律！

#include <iostream>
using namespace std;
int main(){
	// 高精度乘高精度
    string s1,s2;
    int a[251],b[251],c[503]={};
    cin>>s1>>s2;
    for(int i=0;i<s1.size();i++) a[i]=s1[s1.size()-i-1]-'0';
    for(int i=0;i<s2.size();i++) b[i]=s2[s2.size()-i-1]-'0';
    for(int i=0;i<s1.size();i++){
    	for(int j=0;j<s2.size();j++){
			//     ↓ 这里是 +=
    		c[i+j]+=a[i]*b[j];
    		// 进位
    		if(c[i+j]>=10){
    			c[i+j+1]+=c[i+j]/10;
    			c[i+j]%=10;
			}
		}
	}
	int p=0;
	// 找到不是0的数
	for(int i=s1.size()+s2.size()-1;i>=0;i--){
		if(c[i]!=0){
			p=i;
			break;
		}
	}
	// 从p开始输出
	for(int i=p;i>=0;i--){
		cout<<c[i];
	}
	return 0;
}

除法

#include <iostream>
using namespace std;
int main(){
	int a,b,n,t=0,c[1001];
	cin>>a>>b>>n;
	cout<<a/b<<".";
	a=(a%b)*10;
	for(int i=0;i<n;i++){
		c[t++]=a/b;
		a=(a%b)*10;
	}
	for(int i=0;i<t;i++){
		cout<<c[i];
	}
	return 0;
}

这个程序首先接收三个输入：两个整数a和b以及一个整数n，它们分别代表被除数、除数和小数的位数。

然后程序计算出a除以b的商并输出，然后保留这个商的余数。这个余数就是小数点后的第一位。

接着，程序进入一个for循环，该循环执行n次。在每次循环中，它将余数除以b（实际上是一个乘以10的操作），得到下一位小数，然后将这个值存储在数组c中。然后再次保留这个新得到的余数。

最后，程序再输出数组c中的所有值，这些值就是小数a/b的前n位小数。

这个程序使用了小学奥数中的知识：如果你要得到一个数的n位小数，你可以不断地对余数乘以10，然后除以除数，直到得到n位小数为止。

乘方（2的n次方）

思路是高精度乘单精度，单精度的永远是2，然后循环。

#include <iostream>
using namespace std;
int main(){
	/*
    高精度2的乘方
    思路：高精度*单精度2，循环n次
	*/
	int a[251]={1},n,len=1;
	cin>>n;
	for(int i=1;i<=n;i++){
		// 按位相乘
		for(int j=0;j<len;j++){
			a[j]*=2;
		}
		// 处理进位
		for(int j=0;j<len;j++){
			if(a[j]>=10){
				a[j+1]+=a[j]/10;
				a[j]%=10;
			}
		}
		if(a[len]>0) len++;
	}
	for(int i=len-1;i>=0;i--){
		cout<<a[i];
	}
	return 0;
}

1.创建一个长度为251的数组a，并将第一个元素初始化为1。这个数组用来存储每一位的数字。

2.读入一个整数n，表示要计算2的n次方。

3.使用一个外层循环，从1到n进行迭代。在每次循环中，执行以下步骤：
1）使用一个内层循环，从0到len-1进行迭代。这个循环的作用是将数组a中的每一位乘以2。
2）再使用一个内层循环，从0到len-1进行迭代。这个循环的作用是处理进位。如果当前位乘以2之后超过了10，就需要向下一个位置进位。具体做法是，将当前位置除以10的结果加到下一个位置上，然后将当前位置取模10，得到新的当前位置的值。
3）如果处理完所有位置之后，最高位（位置len）的值仍然大于0，就将len加1，表示数组a的长度还需要增加一位。

4.最后，使用一个倒序循环，从len-1到0进行迭代。这个循环的作用是将数组a中的每一位输出到屏幕上。