用C++写一个高精度加减乘除

我可以给出一个示例：#include <stdio.h>

int main()
{
double a, b, c;
char op;

printf("请输入算式（例如：2 + 3）: ");
scanf("%lf %c %lf", &a, &op, &b);

switch(op)
{
case '+':
c = a + b;
break;

case '-':
c = a - b;
break;

case '*':
c = a * b;
break;

case '/':
c = a / b;
break;

default:
printf("无效的运算符\n");
break;
}

printf("%.2lf %c %.2lf = %.2lf\n", a, op, b, c);

return 0;
}

相关问题

高精加减乘除用c++写出来

当然可以，以下是一个简单的高精度加减乘除的 C 代码示例：

#include <stdio.h>
#include <string.h>

#define MAX_LEN 1000

typedef struct {
    int len;
    int num[MAX_LEN];
} BigInt;

void init(BigInt *a) {
    memset(a->num, 0, sizeof(a->num));
    a->len = 0;
}

void assign(BigInt *a, char *s) {
    init(a);
    int len = strlen(s);
    for (int i = len - 1, j = 0, k = 1; i >= 0; i--) {
        a->num[j] += (s[i] - '0') * k;
        if (k == 10000) {
            j++;
            k = 1;
        } else {
            k *= 10;
        }
    }
    a->len = len / 4 + 1;
    while (a->len > 1 && a->num[a->len - 1] == 0) {
        a->len--;
    }
}

void print(BigInt *a) {
    printf("%d", a->num[a->len - 1]);
    for (int i = a->len - 2; i >= 0; i--) {
        printf("%04d", a->num[i]);
    }
    printf("\n");
}

int compare(BigInt *a, BigInt *b) {
    if (a->len != b->len) {
        return a->len - b->len;
    }
    for (int i = a->len - 1; i >= 0; i--) {
        if (a->num[i] != b->num[i]) {
            return a->num[i] - b->num[i];
        }
    }
    return 0;
}

void add(BigInt *a, BigInt *b, BigInt *c) {
    init(c);
    int carry = 0;
    for (int i = 0; i < a->len || i < b->len; i++) {
        int sum = a->num[i] + b->num[i] + carry;
        c->num[c->len++] = sum % 10000;
        carry = sum / 10000;
    }
    if (carry > 0) {
        c->num[c->len++] = carry;
    }
}

void sub(BigInt *a, BigInt *b, BigInt *c) {
    init(c);
    int borrow = 0;
    for (int i = 0; i < a->len || i < b->len; i++) {
        int diff = a->num[i] - b->num[i] - borrow;
        if (diff < 0) {
            diff += 10000;
            borrow = 1;
        } else {
            borrow = 0;
        }
        c->num[c->len++] = diff;
    }
    while (c->len > 1 && c->num[c->len - 1] == 0) {
        c->len--;
    }
}

void mul(BigInt *a, BigInt *b, BigInt *c) {
    init(c);
    for (int i = 0; i < a->len; i++) {
        int carry = 0;
        for (int j = 0; j < b->len; j++) {
            int sum = a->num[i] * b->num[j] + c->num[i + j] + carry;
            c->num[i + j] = sum % 10000;
            carry = sum / 10000;
        }
        if (carry > 0) {
            c->num[i + b->len] += carry;
        }
    }
    c->len = a->len + b->len;
    while (c->len > 1 && c->num[c->len - 1] == 0) {
        c->len--;
    }
}

void div(BigInt *a, BigInt *b, BigInt *c, BigInt *d) {
    init(c);
    init(d);
    for (int i = a->len - 1; i >= 0; i--) {
        d->num[0] = a->num[i];
        d->len = 1;
        int left = 0, right = 9999, mid;
        while (left <= right) {
            mid = (left + right) / 2;
            BigInt tmp, mul;
            init(&tmp);
            init(&mul);
            tmp.num[0] = mid;
            tmp.len = 1;
            mul(&tmp, b, &mul);
            if (compare(&mul, d) <= 0) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        c->num[i] = right;
        BigInt tmp, mul, sub;
        init(&tmp);
        init(&mul);
        init(&sub);
        tmp.num[0] = right;
        tmp.len = 1;
        mul(&tmp, b, &mul);
        sub(a, &mul, &sub);
        assign(a, "");
        add(&sub, &tmp, a);
    }
    while (c->len > 1 && c->num[c->len - 1] == 0) {
        c->len--;
    }
}

int main() {
    BigInt a, b, c, d;
    char s1[MAX_LEN], s2[MAX_LEN];
    scanf("%s%s", s1, s2);
    assign(&a, s1);
    assign(&b, s2);
    add(&a, &b, &c);
    sub(&a, &b, &c);
    mul(&a, &b, &c);
    div(&a, &b, &c, &d);
    print(&c);
    print(&d);
    return 0;
}

这个代码实现了高精度加减乘除四个基本运算，可以处理超过 long long 范围的整数。

c++高精度++运算符重载

C++中的高精度运算符重载是指对整数进行大数运算时，通过重载运算符来实现对大数的加减乘除等操作。一般情况下，C++内置的整数类型（如int、long等）有一定的位数限制，无法处理超过其表示范围的大数。而通过运算符重载，我们可以自定义一个类来表示大数，并对其进行各种运算操作。

以下是一个简单的示例，展示了如何实现C++中的高精度运算符重载：

#include <iostream>
#include <vector>

using namespace std;

class BigInteger {
private:
    vector<int> digits;  // 用vector存储大数的每一位

public:
    BigInteger() {}

    BigInteger(int num) {
        while (num > 0) {
            digits.push_back(num % 10);
            num /= 10;
        }
    }

    BigInteger operator+(const BigInteger& other) const {
        BigInteger result;
        int carry = 0;
        int i = 0;

        while (i < digits.size() || i < other.digits.size() || carry != 0) {
            int sum = carry;
            if (i < digits.size()) {
                sum += digits[i];
            }
            if (i < other.digits.size()) {
                sum += other.digits[i];
            }

            result.digits.push_back(sum % 10);
            carry = sum / 10;
            i++;
        }

        return result;
    }

    friend ostream& operator<<(ostream& os, const BigInteger& num) {
        for (int i = num.digits.size() - 1; i >= 0; i--) {
            os << num.digits[i];
        }
        return os;
    }
};

int main() {
    BigInteger a(123456789);
    BigInteger b(987654321);

    BigInteger c = a + b;

    cout << "a + b = " << c << endl;

    return 0;
}

在上述示例中，我们定义了一个名为BigInteger的类，用于表示大数。通过重载加法运算符`+`，我们可以实现对两个BigInteger对象的相加操作。同时，我们还重载了输出流运算符`<<`，以便能够直接输出BigInteger对象的值。