计算一个非常大的整数

• OP 的代码从最重要到最不重要。从最不重要（最高指数）到最重要添加更容易和更常见，同时跟踪进位。

 // General algorithm.  Needs more work to handle if the lengths of a, b differ.
 carry = 0;
 for (index = least; index >= most; index--) {
   sum = a[index] + b[index] + carry;
   total[index] = sum %10;
   carry = sum / 10;
 }

• OP 的代码不处理 2 个数字的总和是否构成最高有效数字的进位。事实上，它试图设置 .total[-1] = ...

// After the above loop
if (carry) {
  // Shift sum digits "right"
  // Then set the new most significant digit.
}

• 数组应比 长 1，以处理潜在的最后“进位”。totalAB

• long long int A[101] = {0};是过分的。 足以保存所有 1 位和 2 位十进制数字值。signed char A[101] = {0};

---

有什么简单的方法可以做到这一点吗？

也许，对某些人来说很容易，对学习者来说是一个挑战。
一个关键的策略是分而治之。
考虑将输入与加法和输出分开。
Form 3 函数。

// Return length
int big_number_read(int max_length, signed char *destination);

// Return length
int big_number_add(int max_sum_length, signed char *sum, 
    int a_length, signed char *a, 
    int b_length, signed char *b);

void big_number_print(int a_length, signed char *a);

然后形成main()

#define BIGINT_LEN_MAX 100
int main() {
  signed char a[BIGINT_LEN_MAX];
  signed char b[BIGINT_LEN_MAX];
  signed char sum[BIGINT_LEN_MAX + 1];
  int length_a = big_number_read(BIGINT_LEN_MAX, a);
  int length_b = big_number_read(BIGINT_LEN_MAX, b);
  int length_sum = big_number_add(BIGINT_LEN_MAX + 1, sum,
      length_a, a, length_b, b);
  big_number_print(length_sum, sum);
}

计算大型加法的方法存在问题：

• 您应该计算从最低有效数字到最高有效数字的数字，像使用高中算术一样传播进位。
• 如果总和产生的数字大于 和 ，则应为额外的数字腾出空间。AB
• 您应该使用较小的类型来保存数字：对于 to 的范围内的值来说是矫枉过正的。您甚至可以直接使用数字的字符表示。long long int09

下面是代码的修改版本：

#include <stdio.h>

int main(void) {
    int length_A, length_B, length_total, i, j, k, carry;
    int A[101], B[101], total[101];

    if (scanf("%d", &length_A) != 1 || length_A <= 0 || length_A > 100)
        return 1;
    for (i = 0; i < length_A; i++) {
        if (scanf("%1d", &A[i]) != 1)
            return 1;
    }
    if (scanf("%d", &length_B) != 1 || length_B <= 0 || length_B > 100)
        return 1;
    for (i = 0; i < length_B; i++) {
        if (scanf("%1d", &B[i]) != 1)
            return 1;
    }

    length_total = (length_A > length_B) ? length_A + 1 : length_B + 1;
    carry = 0;
    i = length_A;
    j = length_B;
    k = length_total;
    while (i > 0 && j > 0) {
        int digit = A[--i] + B[--j] + carry;
        carry = (digit > 9);
        digit -= carry * 10;
        total[--k] = digit;
    }
    while (i > 0) {
        int digit = A[--i] + carry;
        carry = (digit > 9);
        digit -= carry * 10;
        total[--k] = digit;
    }
    while (j > 0) {
        int digit = B[--j] + carry;
        carry = (digit > 9);
        digit -= carry * 10;
        total[--k] = digit;
    }
    if (carry) {
        total[--k] = carry;
    }
    while (k < length_total) {
        printf("%d", total[k++]);
    }
    printf("\n");
    return 0;
}

下面是一种替代方法，它将数字读取为没有长度前缀的字符串并直接使用字符串：

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

int main(void) {
    char A[101], B[101], total[102];

    if (scanf(" %100[0-9] %100[0-9]", A, B) != 2)
        return 1;

    int length_A = strlen(A);
    int length_B = strlen(B);
    int length_total = (length_A > length_B) ? length_A + 1 : length_B + 1;
    int i = length_A;
    int j = length_B;
    int k = length_total;
    int carry = 0;
    total[k] = '\0';
    while (i > 0 && j > 0) {
        int digit = A[--i] + B[--j] + carry - '0';
        carry = (digit > '9');
        digit -= carry * 10;
        total[--k] = (char)digit;
    }
    while (i > 0) {
        int digit = A[--i] + carry;
        carry = (digit > '9');
        digit -= carry * 10;
        total[--k] = (char)digit;
    }
    while (j > 0) {
        int digit = B[--j] + carry;
        carry = (digit > '9');
        digit -= carry * 10;
        total[--k] = (char)digit;
    }
    if (carry) {
        total[--k] = (char)(carry + '0');
    }
    printf("%s\n", total + k);
    return 0;
}