长整数、高精度运算c语言代码

以下是一个简单的C语言代码示例，实现了长整数（高精度）的加法和乘法运算：

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

#define MAX_LEN 1000

void reverse(char* s) {
    int len = strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - i - 1];
        s[len - i - 1] = t;
    }
}

void add(char* a, char* b, char* result) {
    int len_a = strlen(a);
    int len_b = strlen(b);
    int carry = 0, sum;
    int i = 0, j = 0, k = 0;

    while (i < len_a || j < len_b) {
        int x = i < len_a ? a[i] - '0' : 0;
        int y = j < len_b ? b[j] - '0' : 0;
        sum = x + y + carry;
        carry = sum / 10;
        result[k++] = sum % 10 + '0';
        i++, j++;
    }

    if (carry > 0) result[k++] = carry + '0';
    result[k] = '\0';
    reverse(result);
}

void multiply(char* a, char* b, char* result) {
    int len_a = strlen(a);
    int len_b = strlen(b);
    int carry = 0;
    int i, j, k;

    int* tmp = new int[len_a + len_b];
    memset(tmp, 0, sizeof(int) * (len_a + len_b));

    for (i = 0; i < len_a; i++) {
        carry = 0;
        for (j = 0; j < len_b; j++) {
            tmp[i + j] += (a[len_a - i - 1] - '0') * (b[len_b - j - 1] - '0') + carry;
            carry = tmp[i + j] / 10;
            tmp[i + j] %= 10;
        }
        if (carry > 0) tmp[i + j] += carry;
    }

    k = len_a + len_b - 1;
    while (k > 0 && tmp[k] == 0) k--;

    for (i = 0; i <= k; i++) {
        result[i] = tmp[k - i] + '0';
    }
    result[k + 1] = '\0';

    reverse(result);

    delete[] tmp;
}

int main() {
    char a[MAX_LEN], b[MAX_LEN];
    char result[MAX_LEN * 2];

    scanf("%s%s", a, b);

    add(a, b, result);
    printf("sum: %s\n", result);

    multiply(a, b, result);
    printf("product: %s\n", result);

    return 0;
}

以上代码中，我们定义了两个函数 `add` 和 `multiply`，分别实现了长整数的加法和乘法运算。其中， `add` 函数的思路是模拟竖式加法，从低位开始逐位相加，记录进位，最后再将结果翻转即可。 `multiply` 函数的思路是模拟竖式乘法，先将结果的每一位初始化为0，然后从低位开始逐位相乘并加到对应的位上，最后将结果翻转即可。

在 `main` 函数中，我们通过 `scanf` 读入两个长整数，并调用 `add` 和 `multiply` 函数分别计算它们的和和积，最后输出结果。值得注意的是，由于本题需要计算的数可能非常大，因此在 `multiply` 函数中我们使用了动态分配内存的方式，避免了数组大小限制。同时，为了方便处理，我们将结果翻转后输出，这样可以避免在计算时处理高位进位问题。