1.高精度加法

​ 思想：分别用两个数组逆存储两个整数的值，数组下标为0的值存储个位，为1存在十位，以此类推；

​ 再通过模拟加法进位来将得到的值的每一位存储的新数组当中，得到相加数

模板

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <vector>
#include <string>

using namespace std;

const int N = 1000010;

vector<int> add(vector<int> &A, vector<int> &B)//传址调用，节省占用，无需再另拷贝新数组
{
	vector<int> C;
	int t = 0;
	for (int i = 0;i < A.size() || i < B.size();++i)
	{
		if (i < A.size()) t += A[i];
		if (i < B.size()) t += B[i];
		C.push_back(t % 10);
		t /= 10;
	}
	if (t) C.push_back(1);
	return C;
}
int main()
{
	string a, b;
	vector <int> A, B;
	cin >> a >> b;// a = "123456"
	for (int i = a.size( )-1;i >= 0;--i) A.push_back(a[i] - '0');//{6,5,4,3,2,1}
	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];
	}
	
	return 0;
}

2.高精度减法

​ 思想：分别用两个数组逆存储两个整数的值，数组下标为0的值存储个位，为1存在十位，以此类推；

​ 提前判断A，B的谁大谁小，使得最终能够大数减小数，如果是B-A，还要提前打印一个负号

​ 再通过模拟减法运算，将得到的值的每一位存储的新数组当中，得到相减数，最后注意前导0的存在

模板

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <vector>
using namespace std;
bool cmp(vector<int>& A, vector<int>& B)//判断A是否大于等于B
{
	if (A.size() != B.size()) return A.size() > B.size();
	for (int i = A.size() - 1;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];// 检测B是否越界
		C.push_back((t + 10) % 10);//t为正数与t为负数两种情况判断
        // 比如7-8 是负数，模拟减法后则为10+7-8，之后也要后面一位减1
		if (t < 0) t = 1;
		else t = 0;
	}
	while (C.size() > 1 && C.back() == 0) C.pop_back(); //防止前导0的存在，需要去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) cout << C[i];
	}
	else
	{
		auto C = Sub(B, A);
		cout << '-';
		for (int i = C.size() - 1;i >= 0;--i) cout << C[i];
	}
	
	return 0;
}

3.高精度相乘 （大整数x小整数）

​ 思想：用一个数组逆存储一个整数的值，数组下标为0的值存储个位，为1存在十位，以此类推；用int 存储一个较小数

​ 通过将大数每一位的值与B相乘，并且每次运算只把算得的个位传给C，下一次将上次除去个位的数加上这一次相乘的值，最后将留下来的未能放进C的数再放进C中，得到最终的相乘数

模板

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
#include <vector>

using namespace std;

vector<int> Mul(vector<int> &A, int &b)
{
	int t = 0;
	vector<int> C;
	for (int i = 0;i < A.size();++i)
	{
		t += A[i] * b;
		C.push_back(t % 10);//只往C中传个位数，其余位数暂时保留
		t /= 10;
	}
	while (t)//排除前导0
	{
		C.push_back(t % 10);
			t /= 10;
	}
	return C;
}
int main()
{
	string a;
	vector<int> A;
	int b;
	cin >> a>>b;
	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;
}

4.高精度相除（大整数/小整数）

​ 思想：用一个数组逆存储一个整数的值，数组下标为0的值存储个位，为1存在十位，以此类推；用int 存储一个较小数

​ 和之前一样，但这次是从高位到低位，目的是模拟除法。并通过每次的余数来推演下一次的运算，比如算1234/11，第一位得到的余数r是1，

然后通过将余数r*10+下一位的数，得到12，12/11得到余数1，以此类推，最后得到的就是两数之商，同时也可得到最终的余数

模板

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <vector>
#include <string>

using namespace std;
vector<int> Div(vector<int> &A, int &b, int &r)
{
	vector<int> C;
	r = 0;
	for (int i = A.size() - 1;i >= 0;--i)
	{
		r = r * 10 + A[i];//上一次的余数*10+这一次要除的数，模拟除法
		C.push_back(r / b);//每一位的商
		r %= b;//余数
	}
	reverse(C.begin(), C.end());//得到的商是正过来的，而我们想要倒着输出，因此就要让商再倒过来
	while (C.size() > 1 && C.back() == 0) C.pop_back();//排除前导0
	return C;
}
int main()
{
	string a;
	int b;
	vector<int> A;
	cin >> a >> b;
	for (int i = a.size() - 1;i >= 0;--i) A.push_back(a[i] - '0');
	int r;
	auto C = Div(A, b,r);

	for (int i = C.size() - 1;i >= 0;--i) cout << C[i];//商
	cout << endl;
	cout << r;//余数
	return 0;
}

小注

​ 位数最大为1e6(10 的6 次方)

​ 加减乘除四种存储方式是相同的