C 如何为大整数实现整数数组加法器？

由于C不像JAVA那样支持大整数，所以我尝试实现一个整数加法器函数，该函数将两个整数数组作为参数，并返回一个指向它们的和的指针，这也是一个数组。这是我的密码

#include<stdio.h>
#include<stdlib.h>
int max(int a,int b) {
    return a < b ? b : a;
}

int* decimalAdder (int* p, int* q) {
    int size1, size2, i;
    size1 = sizeof(p) / sizeof(int);
    size2 = sizeof(q) / sizeof(int);
    int m = max(size1, size2) + 1;
    int* c = (int*)malloc(m * sizeof(int));
    int carry = 0;
    for(i=0 ; i<m ; i++) {
        c[i] = 0;
        if(i < size1 && i < size2) {
            c[i] += p[i] + q[i] + carry;
            if(c[i] >= 10) {
                c[i] = c[i] % 10;
                carry = 1;
            }
            else
                carry = 0;
        }
        else if(i < size1) {
            c[i] += p[i] + carry;
            if(c[i] >= 10) {
                c[i] = c[i] % 10;
                carry = 1;
            }
            else
                carry = 0;
        }
        else if(i < size2) {
            c[i] += q[i] + carry;
            if(c[i] >= 10) {
                c[i] = c[i] % 10;
                carry = 1;
            }
            else
                carry = 0;
        }
        else
            c[i] += carry;
    }
    return c;
}

//Test program
int main() {
    int a[] = {7, 5, 3, 6};
    int b[] = {3, 5, 3};
    int* sum;
    int i;
    sum = decimalAdder(a, b);
    int size = sizeof(sum) / sizeof(int);
    for(i = size ; i >= 0 ; i--)
        printf("%d", sum[i]);
    free(sum);
    sum=NULL;
    return 0;
}

#包括
#包括
最大整数（整数a，整数b）{
返回a=10）{
c[i]=c[i]%10；
进位=1；
}
其他的
进位=0；
}
否则，如果（i=10）{
c[i]=c[i]%10；
进位=1；
}
其他的
进位=0；
}
其他的
c[i]+=进位；
}
返回c；
}
//测试程序
int main（）{
int a[]={7,5,3,6}；
int b[]={3,5,3}；
整数*和；
int i；
总和=小数位数（a，b）；
int size=sizeof（sum）/sizeof（int）；
对于（i=size；i>=0；i--）
printf（“%d”，和[i]）；
免费（金额）；
总和=零；
返回0；
}

它输出10 我错在哪里？我错过了什么

但是如果未知，如何确定p和q的真实大小呢

像这样：

#include<stdio.h>

void returnLen(int length){
    printf("The length of Array is:\t%d\n",length);
}

int main(void){
    int array[] = {7, 5, 3, 6, 1, 9, 3, 6, 2, 10, 55};
    int length = sizeof array / sizeof array[0];

    returnLen(length);
    return 0;
}

#包括
无效返回长度（整数长度）{
printf（“数组的长度为：\t%d\n”，长度）；
}
内部主（空）{
int数组[]={7,5,3,6,1,9,3,6,2,10,55}；
int length=sizeof数组/sizeof数组[0]；
返回长度；
返回0；
}

输出：

数组长度为：11

---

如注释中所述，

sizeof（p）

和

sizeof（q）

与

sizeof（int*）

相同。您需要将真实数组大小作为参数传递给

decimalAdder（）

因此，首先，更改

decimalAdder（）

以接收大小：

int *decimalAdder (int *p, size_t size1, int *q, size_t size2) {
    int i;
    int m = max(size1, size2) + 1;
    int *c = malloc(m * sizeof(int));
    /* ... */
}

您询问如何确定要将其传递给

decimalAdder（）

的数组的大小。好的，如果您动态地分配了数组，那么您可能知道数组的大小（与您之前传递给

malloc（3）

的大小相同）

如果数组是堆栈分配的（这里就是这种情况），您可以使用在

main（）

中使用的

sizeof（）

方法，但只能在声明数组的函数内部使用（因为一旦将本地数组传递给另一个函数，它就会衰减为指向第一个元素的指针，并且您无法再确定其大小）

因此，在这种情况下，您可以将

main（）

更改为：

int main(void) {
    int a[] = {7, 5, 3, 6};
    int b[] = {3, 5, 3};
    size_t size1 = sizeof(a)/sizeof(a[0]);
    size_t size2 = sizeof(b)/sizeof(b[0]);
    int* sum;
    int i;
    sum = decimalAdder(a, size1, b, size2);    
    int size = max(size1, size2);

    for(i = size ; i >= 0 ; i--)
        printf("%d", sum[i]);

    free(sum);
    sum=NULL;

    return 0;
}

---

注意

int size=sizeof（sum）/sizeof（int）

无法按您期望的方式工作：

sum

不是真正的数组，它是指向

int

的指针，因此

sizeof（sum）

与

sizeof（int*）

相同，而不是您分配的数组大小。C不跟踪它，你必须自己做（与Java相反）。

因为C中的整数数组是一种简单的类型，在一般情况下，它不携带关于其大小的信息。有很多方法可以解决这个问题。Michi的答案对于静态分配的数组是正确的，如果您总是知道将使用多少个数组元素，那么这可能足以满足您的需要。但是，如果是这样的话，那么整个练习是没有意义的，因为您可以使用宏化常量并获得相同的结果

最终，您将要做的是创建一个数据结构，该结构可用于携带位数（或多位数元素）。根据此代码的使用方式，类似的操作可能会起作用：

struct myArray{
    int length;
    int *digits;
};

这意味着您必须管理结构的内存（分配、释放、调整大小等）。此外，您可能会考虑使用“包含”和“INT64”或“Unt64”作为数组元素，因为您将能够使用较少的单元来表示给定的大int。

---

数据结构（如上）绝不是唯一的解决方案。你也可以使用一个链表（尽管如果你只需要在节点上做简单的算术运算的话，这个链表的重量相当大）。

sizeof（p）

和

sizeof（q）

与

sizeof（int*）

是一样的。您需要将真正的数组大小作为参数传递给

decimalAdder（）

。谢谢。注意。但是，如果p和q的大小未知，如何确定它们的真实大小呢？要么将长度作为类型为

size\u t

的附加参数传递，要么添加一个跟C字符串一样的尾随空字节。即使我想将数组大小作为参数传递，数组大小仍然需要确定。怎么做？这个问题和我做的一样。虽然C没有内置大整数，但是你可以使用像libgmp这样的库来得到类似的结果。我做了同样的事情。size1=sizeof（p）/sizeof（int）；这不一样，因为返回的是指针的大小，而不是数组的大小size@user132458只能在声明本地数组的函数中使用

sizeof

技巧。这是因为一旦一个数组被传递给另一个函数，它就会退化为指向第一个元素的指针，因此您无法再确定它的大小。有关更多详细信息，请参见我的答案。使用

sizeof

确定数组大小也适用于可变长度数组，而不仅仅是静态分配（如您的答案所示）。不同之处（这里不相关）在于

sizeof

计算其操作数（如果它是VLA）。谢谢，先生。这确实有帮助。修复了我的代码和它的工作。你能告诉我一些很好的参考资料来深入理解C操作符，比如sizeof吗？