C 使用斐波那契序列的动态分配数组中的最高有效位错误

我在做一个赋值，在这个赋值中，我需要使用一个指向一个数字的int指针的结构，在指针中存储n个数字。将结构的两个实例相加，并将这两个结构传递到一个斐波那契序列函数中，因此第一个填充的结构将是斐波那契[0]，第二个填充的结构将是斐波那契[1]，而这两个相加的结构将是斐波那契[2]，依此类推。赋值中的一个关键注意事项是确保动态分配的数组不会传递特定的数字值，例如，指令中说每个斐波那契迭代有50个数字，在这个示例中，我已经硬编码了

我的问题是，我产生了一个近似正确的斐波那契值，然而，当我得到斐波那契[4]时，我的值在最高有效位上偏离了1位。对于Fibonacci的前3次迭代，我生成了正确的值，但从那里开始，我相信它开始使用一个差一位数的值，因此最终生成的数字与预期的完全不同

我一直在摆弄我的斐波那契函数，但是我相信这个问题可能在我的addFunction中，进位有问题，我只是在这一点上被难住了，昨天花了一整天的时间只研究斐波那契求和问题

 #define MAX 3

typedef struct Integer
{
    int *number;

} Integer;

Integer *addFunction(Integer *intA, Integer *intB)
{
    int carry = 0, drop, i;

    if (intA == NULL)
    {
        printf("Null Pointer: intA");
        return NULL;
    }
    if (intB == NULL)
    {
        printf("Null Pointer: intB");
        return NULL;
    }

    Integer *intSum = malloc(sizeof(Integer));
    intSum->number = malloc(sizeof(int));

    for (i=0; i<=2; i++)
    {
        intSum->number[i] = intA->number[i] + intB->number[i] + carry;

        if (intSum->number[i] > 9)
        {
            drop = intSum->number[i] % 10;
            carry = intSum->number[i] / 10;
            intSum->number[i] = drop;
        }
    }

    return intSum;
}

void printFunction(Integer *intC)
{
    int i;

    if (intC == NULL)
    {
        printf("Null Pointer");
        return;
    } 

    for (i=MAX-1; i>=0; i--)
    {
        printf("%d", intC->number[i]);
    }

    printf("\n");
}

Integer *loadFirstVariable(int a[])
{
    int i;

    Integer *intA = malloc(sizeof(Integer));
    intA->number = malloc(sizeof(int));

    for (i=0; i<=2; i++)
    {
        intA->number[i] = a[i];
    }

    return intA;
}

Integer *loadSecondVariable(int b[])
{
    int i;

    Integer *intB = malloc(sizeof(Integer));
    intB->number = malloc(sizeof(int));

    for (i=0; i<=2; i++)
    {
        intB->number[i] = b[i];
    }

    return intB;
}

Integer *fibonacci(int n, Integer *first, Integer *second)
{

    int i, y, z;

    Integer *fibSum = malloc(sizeof(Integer));
    fibSum->number = malloc(sizeof(int));

    if (n == 0)
        return first;
    if (n == 1)
        return second;
    if (n >= 2)
    {
        for (i=2; i<=n; i++)
        {
            *fibSum = (*addFunction(first, second));

            for (y=0; y<=2; y++)
            {
                first->number[y] = second->number[y];
                second->number[y] = fibSum->number[y];
            }
        }

        return fibSum;
    }
}

int main ()
{
    int a[3] = {7, 3, 4};
    int b[3] = {2, 9, 5};

    printf("Fibonacci Sequence\n");
    printFunction(fibonacci(4, loadFirstVariable(a), loadSecondVariable(b)));
}

#定义最大值3
typedef结构整数
{
整数*数字；
}整数；
整数*addFunction（整数*intA，整数*intB）
{
int进位=0，下降，i；
如果（intA==NULL）
{
printf（“空指针：intA”）；
返回NULL；
}
if（intB==NULL）
{
printf（“空指针：intB”）；
返回NULL；
}
整数*intSum=malloc（sizeof（Integer））；
intSum->number=malloc（sizeof（int））；
对于（i=0；inumber[i]=intA->number[i]+intB->number[i]+进位；
如果（整数->数字[i]>9）
{
drop=intSum->number[i]%10；
进位=整数->数字[i]/10；
整数->数字[i]=下降；
}
}
返回整数；
}
void打印函数（整数*intC）
{
int i；
if（intC==NULL）
{
printf（“空指针”）；
返回；
} 
对于（i=MAX-1；i>=0；i--）
{
printf（“%d”，intC->number[i]）；
}
printf（“\n”）；
}
整数*loadFirstVariable（int a[]）
{
int i；
整数*intA=malloc（sizeof（整数））；
intA->number=malloc（sizeof（int））；
对于（i=0；inumber[i]=a[i]；
}
返回intA；
}
整数*loadSecondVariable（int b[]）
{
int i；
整数*intB=malloc（sizeof（Integer））；
intB->number=malloc（sizeof（int））；
对于（i=0；inumber[i]=b[i]；
}
返回intB；
}
整数*斐波那契（整数n，整数*第一，整数*第二）
{
int i，y，z；
整数*fibSum=malloc（sizeof（整数））；
fibSum->number=malloc（sizeof（int））；
如果（n==0）
先返回；
如果（n==1）
返回第二；
如果（n>=2）
{
对于（i=2；inumber[y]；
第二个->数字[y]=fibSum->数字[y]；
}
}
返回fibSum；
}
}
int main（）
{
inta[3]={7,3,4}；
int b[3]={2,9,5}；
printf（“斐波那契序列”）；
打印函数（fibonacci（4，loadFirstVariable（a），loadSecondVariable（b））；
}

1）

intB->number=malloc（sizeof（int））；

-->

intB->number=malloc（MAX*sizeof（int））；

2）添加3位数字可能会产生4位结果。例如，999+999=1998似乎前两位数字应该是

a[3]={0,0,0}；

和

b[3]={1,0,0}

。