大数加减法的问题主要产生于计算机基本数据类型的表示范围限制。通常情况下，计算机采用有限位数的数据类型（如int、long）来表示整数，这些数据类型的表示范围有限，无法表示超出范围的大整数。
例如超过了long类型的表示范围（通常为-9223372036854775808 到 9223372036854775807），就无法直接使用基本数据类型进行计算。这时候就需要使用特殊的方法来表示和处理这些大数。
在实际应用中，大数加减法常见于金融计算、科学计算、密码学等领域。例如，在金融领域中，需要处理非常大的金额或利率；在科学计算中，可能需要处理超过基本数据类型表示范围的测量数据或计算结果；在密码学中，需要处理大素数或大整数来进行加密、解密等操作。
-
大数表示方法：使用字符串或数组等数据结构来表示大数。每个位上的数字可以用字符 '0' 到 '9' 来表示，例如："12345678901234567890"。
-
大数加法：
- 从两个大数的最低位开始逐位相加，将结果存储到一个新的字符串或数组中。
- 需要考虑进位的情况，即当相加结果超过9时，需要将进位加到下一位的运算中。
- 需要考虑两个大数长度不等的情况。
-
大数减法：
- 从两个大数的最低位开始逐位相减，将结果存储到一个新的字符串或数组中。
- 需要考虑借位的情况，即当相减结果小于0时，需要向高位借位。
- 需要考虑被减数小于减数的情况，可以在代码中进行判断并抛出异常或返回特定结果。
-
进位和借位处理：编写逻辑来处理加法中的进位和减法中的借位。
运算符重载函数声明为 BigInt 类的友元函数是为了在不暴露私有成员的情况下，让它们能够有效地操作 BigInt 对象。
class BigInt
{
public:
BigInt(string str) : strDigit(str){ }
private:
string strDigit;//使用字符串存储大整数
//都是全局函数声明为友元
friend ostream& operator<<(ostream& out, const BigInt& src);
friend BigInt operator+(const BigInt& lhs, const BigInt& rhs);
friend BigInt operator-(const BigInt& lhs, const BigInt& rhs);
}; 重载输出流插入运算符 <<，允许使用 << 将 BigInt 对象输出到输出流中。ostream& out 是一个输出流对象的引用，它表示要输出的目标流，而 const BigInt& src 是一个常量引用，表示要输出的 BigInt 对象。
ostream& operator<<(ostream& out, const BigInt& src)
{
out << src.strDigit;
return out;
}完整代码：
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
class BigInt
{
public:
BigInt(string str) : strDigit(str){ }
private:
string strDigit;//使用字符串存储大整数
//都是全局函数声明为友元
friend ostream& operator<<(ostream& out, const BigInt& src);
friend BigInt operator+(const BigInt& lhs, const BigInt& rhs);
friend BigInt operator-(const BigInt& lhs, const BigInt& rhs);
};
//打印函数
ostream& operator<<(ostream& out, const BigInt& src)
{
out << src.strDigit;
return out;
}
//大数加法
BigInt operator+(const BigInt& lhs, const BigInt& rhs) {
//从后往前遍历字符串lhs，和rhs，用flag来标记是否需要进位，结果存在result数组中（反向的）
string result;
bool flag = false;
int i = lhs.strDigit.length() - 1;//string的length和size没有区别，length是沿用C语言习惯，早先只有length
int j = rhs.strDigit.length() - 1;
for (; i >= 0 && j >= 0; --i, --j) //i 和 j其中一个会被减到负数然后退出for循环
{
int ret = lhs.strDigit[i] - '0' + rhs.strDigit[j] - '0';//单个位加减时需要减'0'转成整型,每次都重新定义一个新的ret
if (flag)
{
ret += 1;//flag为true说明此位因为上一位进位而需要多加一个1
flag = false;//再将其重新置为false
}
//两个if不能互换，否则不是下一位进1
if (ret >= 10)
{
ret %= 10;
flag = true;
}
result.push_back(ret + '0');
}
//如果遍历完,i还有剩下,第一个字符串没完
if (i >= 0)//注意要取等，因为更短的那个字符串的下标是被减到-1，而不是0，0依然说明还剩余1位
{
while (i >= 0)
{
int ret = lhs.strDigit[i] - '0';
if (flag) //前面加过来可能还有进位，然后当前可能为9，加了1之后又 = 10，又得进位，所以直接复制前面的代码
{
ret += 1;
flag = false;
}
if (ret >= 10)
{
ret %= 10;
flag = true;
}
result.push_back(ret + '0');
i--;
}
}
//第二个字符串没完
else if (j >= 0)
{
while (j >= 0)
{
int ret = lhs.strDigit[j] - '0';
if (flag) //前面加过来可能还有进位，然后当前可能为9，加了1之后又 = 10，又得进位，所以直接复制前面的代码
{
ret += 1;
flag = false;
}
if (ret >= 10)
{
ret %= 10;
flag = true;
}
result.push_back(ret + '0');
j--;
}
}
//最高位可能也进位
if (flag) {
result.push_back('1');
}
reverse(result.begin(), result.end());
return result;//result是string类，而不是BigInt，因为隐式转换，p263
//因为编译器看到该类的构造函数只接受一个实参(而且是string类的)，所以可以触发隐式转换机制，定义string result时编译器也会构建一个BigInt类的临时对象，并把result赋值给他
//函数里的return本来就是返回临时对象，这个时候就返回的就是那个BigInt类的临时对象
//当然，参考书上的例子，即使后面函数用string类的result，编译器实际传入的也是BigInt的临时对象
//如某成员函数定义为func(BigInt& a){...}; 调用时传入string类 func(result);也是合法的
}
//大数减法
BigInt operator-(const BigInt& lhs, const BigInt& rhs) {
//让大的减小的，如果lhs比rhs小，则让rhs - lhs，然后最后添加负号
string result;
bool flag = false;
bool minor = false;//标记lhs是否和rhs互换了
string maxStr = lhs.strDigit;
string minStr = rhs.strDigit;
if (maxStr.length() < minStr.length())
{
//互换，让maxStr一直是最长的
maxStr = rhs.strDigit;
minStr = lhs.strDigit;
minor = true;
}
//长度一样也得比较
else if (maxStr.length() == minStr.length())
{
if (maxStr < minStr)
{
maxStr = rhs.strDigit;//让maxStr是最大的
minStr = lhs.strDigit;
minor = true;
}
else if (maxStr == minStr)
{
return string("0");
}
}
int i = maxStr.length() - 1;//i肯定大于等于j，所以后面j会先完
int j = minStr.length() - 1;
for (; i >= 0 && j >= 0; --i, --j) {
int ret = maxStr[i] - minStr[j];//减法的话，char类型相减就是int型了，不用+‘0’再相减
/*if (ret >= 0)
{
result.push_back(ret + '0');
} 一定要先看标记，因为被借位的话，当前ret需要减1*/
if (flag)
{
ret -= 1;
flag = false;
}
//当前位有可能因为被借位了而减，小于0，所以紧接着判断是否为负
if (ret < 0)
{
ret += 10;// 如2 - 6，应该是12 - 6，所以为 2 - 6 + 10 = 6
flag = true;
}
result.push_back(ret + '0');
}
//肯定是j先完，所以不用再像加法那样判断，而是直接把i多余的处理完
while (i >= 0) {
int ret = maxStr[i] - '0';
if (flag) {
ret -= 1;
flag = false;
}
//同样的,ret可能原本是0，被借位了又为-1了
if (ret < 0) {
ret += 10;
flag = true;
}
result.push_back(ret + '0');
i--;
}
//翻转前先看看末尾有没有0，如1000，否则反转后就是0001
while(result.back() == '0')
{
result.pop_back();
}
if (minor) {
result.push_back('-');
}
reverse(result.begin(), result.end());
return result;
}
int main()
{
string s1;
string A;
string s2;
getline(cin, s1);
getline(cin, A);//把加减号定义为char会报错，getline第二个参数只能是string类型
getline(cin, s2);
BigInt int1(s1);
BigInt int2(s2);
if (A == "+") {
cout << int1 + int2 << endl;
}
if (A == "-") {
cout << int1 - int2 << endl;
}
return 0;
}
