求救！

最近脑子抽抽 脑浆爆满了，想写个重载运算符高精加减乘除，但那问题真的超超超多，有没有巨/大/中/小 佬帮忙看看：

#include <bits/stdc++.h>

using namespace std;

// 定义大整数最大位数
const int MAX_DIGITS = 1000;

// 大整数结构体
struct BigInteger {
    char digits[MAX_DIGITS]; // 数字数组
    int numDigits;           // 数字位数
    bool isNegative;         // 是否为负数

    // 默认构造函数，初始化大整数为0
    BigInteger() : numDigits(1), isNegative(false) {
        // 将数字数组初始化为0
        for (int i = 0; i < MAX_DIGITS; ++i)
            digits[i] = 0;
    }

    // 根据字符串构造大整数
    BigInteger(const string& numStr) : numDigits(0), isNegative(false) {
        // 遍历字符串中的每个字符，并将其转换为数字存储到数组中
        int len = strlen(numStr.c_str());
        if (len > 0 && numStr[0] == '-') {
            isNegative = true;
            len--; // 负号不计入位数
        }
        for (int i = len - 1; i >= 0; --i)
            digits[numDigits++] = numStr[i] - '0';
    }

    	// 加法运算符重载，接受整数参数
    BigInteger operator+(int num) {
        // 将整数转换为大整数，然后执行加法运算
        BigInteger numBigInt(to_string(num));
        return (*this) + numBigInt;
    }
    
    // 减法运算符重载，接受整数参数
    BigInteger operator-(int num) {
        // 将整数转换为大整数，然后执行减法运算
        BigInteger numBigInt(to_string(num));
        return (*this) - numBigInt;
    }
    
    // 乘法运算符重载，接受整数参数
    BigInteger operator*(int num) {
        // 将整数转换为大整数，然后执行乘法运算
        BigInteger numBigInt(to_string(num));
        return (*this) * numBigInt;
    }

	// 除法运算符重载，接受整数参数
    BigInteger operator/(int num) {
        // 将整数转换为大整数，然后执行除法运算
        BigInteger numBigInt(to_string(num));
        return (*this) / numBigInt;
    }
	
	
	 
    // 加法运算符重载
    BigInteger operator+(BigInteger& other) {
        BigInteger result; // 结果大整数
        int carry = 0;     // 进位
        int maxDigits = max(numDigits, other.numDigits); // 获取两个大整数中的最大位数
        // 逐位相加
        for (int i = 0; i < maxDigits || carry; ++i) {
            int sum = carry;
            if (i < numDigits) sum += digits[i];
            if (i < other.numDigits) sum += other.digits[i];
            result.digits[i] = sum % 10;
            carry = sum / 10;
            ++result.numDigits;
        }
        return result;
    }

    // 减法运算符重载
    BigInteger operator-(BigInteger& other) {
        BigInteger result; // 结果大整数
        int borrow = 0;    // 借位
        // 逐位相减
        for (int i = 0; i < numDigits; ++i) {
            int diff = digits[i] - borrow;
            if (i < other.numDigits) diff -= other.digits[i];
            if (diff < 0) {
                diff += 10;
                borrow = 1;
            } else {
                borrow = 0;
            }
            result.digits[i] = diff;
            ++result.numDigits;
        }
        // 移除结果中的前导零
        while (result.numDigits > 1 && result.digits[result.numDigits - 1] == 0)
            --result.numDigits;
        return result;
    }
    
	// 乘法运算符重载
	BigInteger operator*(BigInteger& other) {
	       BigInteger result; // 结果大整数
	       // 逐位相乘
	       for (int i = 0; i < numDigits; ++i) {
	           int carry = 0;
	           for (int j = 0; j < other.numDigits || carry; ++j) {
	               int product = result.digits[i + j] +
	                             digits[i] * (j < other.numDigits ? other.digits[j] : 0) + carry;
	               result.digits[i + j] = product % 10;
	               carry = product / 10;
	               // 更新结果的位数
	               if (i + j >= result.numDigits && product > 0)
	                   result.numDigits = i + j + 1;
	           }
	       }
	    return result;
	}
	    
	// 除法运算符重载
    BigInteger operator/(BigInteger& other) {
        BigInteger quotient, remainder; // 商和余数
        // 从高位到低位逐步计算商和余数
        for (int i = numDigits - 1; i >= 0; --i) {
            remainder = remainder * 10;
            remainder.digits[0] = digits[i];
            int x = 0, left = 0, right = 9;
            // 二分法找商
            while (left <= right) {
                int mid = (left + right) / 2;
                BigInteger temp = other * mid;
                if (temp.digits[0] <= remainder.digits[0]) {
                    x = mid;
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
            quotient = quotient * 10 + x;
            remainder = remainder - other * x;
        }
        return quotient;
    }

    


    // 输出运算符重载
    friend ostream& operator<<(ostream& os, BigInteger& num) {
        if (num.isNegative && !(num.numDigits == 1 && num.digits[0] == 0))
            os << "-"; // 如果是负数且不是零，则输出负号
        // 逐位输出数字
        for (int i = num.numDigits - 1; i >= 0; --i)
            os << (char)(num.digits[i] + '0');
        return os;
    }
};

int main() {
    // 测试用例
    BigInteger num1,num2; 
    cin >> num1 >> num2;
    

    // 输出结果
    cout << "num1 + num2 = " << num1 + num2 << endl;
    cout << "num1 - num2 = " << num1 - num2 << endl;
    cout << "num1 * num2 = " << num1 * num2 << endl;
    cout << "num1 / num2 = " << num1 / num2 << endl;

    return 0;
}

谢谢！