高精度运算（C++）

高精度加法：

string add(const string& A, const string& B)
{
    string C;
    int t = 0;
    for (int i = A.size()-1, j = B.size()-1; i >= 0 || j >= 0 || t > 0; i--, j--)
    {
        if (i >= 0) t += (A[i] - '0');
        if (j >= 0) t += (B[j] - '0');
        C = (char)((t % 10) + '0') + C;
        t /= 10;
    }
    return C;
}

高精度减法：

string a, b;

bool bigger(string a, string b)
{
    if(a.size() != b.size()) return a.size() > b.size();
    for(int i = 0; i < a.size(); i ++)
        if(a[i] != b[i]) return a[i] > b[i];
    return true;
}

string jian(string a, string b)
{
    reverse(a.begin(), a.end());
    reverse(b.begin(), b.end());
    string c;
    for(int i = 0, t = 0; i < a.size(); i ++)
    {
        t = a[i] - '0' - t;
        if(i < b.size()) t -= b[i] - '0';
        c += (t + 10) % 10 + '0';
        if(t < 0) t = 1;
        else t = 0;
    }
    while(c.size() > 1 && c.back() == '0') c.pop_back();
    reverse(c.begin(), c.end());
    return c;
}

int main()
{
    cin >> a >> b;
    if(bigger(a, b)) cout << jian(a, b);
    else cout << '-' << jian(b, a);
    return 0;
}

高精度乘法：

string mcl(string a, string b){
    string ans;
    reverse(a.begin(), a.end());
    reverse(b.begin(), b.end());
    /* k：ans字符串可能的最大位数 */
    int c[1000]={0}, k = a.size()+b.size()+1;
    /* 从个位开始，模拟乘法：a的每一位乘以b的每一位 */
    for(int i = 0; i < a.size(); i++)
        for(int j = 0; j < b.size(); j++){
            c[i+j] += (a[i]-'0')*(b[j]-'0');  /* c[i+j]暂存初步乘的结果 */
            c[i+j+1] += c[i+j]/10;   /* 进位 */
            c[i+j] %= 10;       /* c[i+j]保留个位 */
        }
    /* 去除高位‘0’ */
    while(c[k]==0 && k>=0) k--;
    /* 输出 */
    while(k >= 0)
        ans.push_back(c[k--]+'0');
    return ans;
}

高精度除法：

高精度/低精度 除法

A：高精度数 / 采用string类型读取
B：低精度数 / 采用long long类型读取

string div(string a, long long b){
	string ans;
	/* rest：存储余数 */
    int c[256] = {0}, rest = 0;
    /* 从最高位开始，模拟除法 */
    for(int i = 0; i < a.size(); i++){
        rest = 10*rest + a[i] - '0';
        c[i] = rest / b;
        rest %= b;
    }
    // 处理计算结果
    int k = 0;
    /* 去除高位‘0’，k最大不能超过a.size()-1，因为商最少也会有1位 */
    while(c[k] == 0 && k < a.size()-1)
        k++;
    for(int i = k; i < a.size(); i++)
        ans.push_back(c[i]+'0');
    return ans;
}       

高精度/高精度 除法

// 执行高精度除法的函数
string highPrecisionDivision(string dividend, string divisor) {
    string quotient = ""; // 结果商
    string remainder = ""; // 除法后的余数
 
    int divisorLength = divisor.length(); // 除数的长度
 
    // 逐位处理被除数的数字
    for (size_t i = 0; i < dividend.length(); ++i) {
        // 将被除数的下一位数字附加到余数上
        remainder += dividend[i];
 
        // 检查余数是否足够大以进行除法运算
        if (remainder.length() >= divisorLength) {
            // 执行除法
            int count = 0;
            string tempDividend = remainder;
 
            // 反复从被减数中减去除数，直到被减数变小
            while (tempDividend >= divisor) {
                tempDividend = highPrecisionSubtraction(tempDividend, divisor);
                count++;
            }
 
            // 将商的计数附加到商中
            quotient += to_string(count);
 
            // 更新余数
            remainder = tempDividend;
        } else {
            // 如果余数小于除数，则将'0'附加到商中
            quotient += "0";
        }
    }
 
    // 从商中删除前导零
    quotient.erase(0, min(quotient.find_first_not_of('0'), quotient.size()-1));
 
    // 如果余数为空，则返回商；否则返回"商："加上商和余数
    if (remainder.empty())
        return quotient;
    else
        return "商：" + quotient + "，余数：" + remainder;
}
 
// 执行高精度减法的函数（如前一个回答中所述）
string highPrecisionSubtraction(string num1, string num2) {
    string result = "";
    int carry = 0;
 
    reverse(num1.begin(), num1.end());
    reverse(num2.begin(), num2.end());
 
    for (size_t i = 0; i < num1.length(); ++i) {
        int digit1 = (i < num1.length()) ? (num1[i] - '0') : 0;
        int digit2 = (i < num2.length()) ? (num2[i] - '0') : 0;
        
        int diff = digit1 - digit2 - carry;
 
        if (diff < 0) {
            diff += 10;
            carry = 1;
        } else {
            carry = 0;
        }
 
        result += to_string(diff);
    }
 
    while (result.length() > 1 && result.back() == '0') {
        result.pop_back();
    }
 
    reverse(result.begin(), result.end());
 
    return result;
}