C 如何使用函数查找两个等长数组中每个元素之间的差异

该函数假定检查两个数组的大小是否相同。如果是，比较两个数组的每个索引，看看哪个索引的值更大。将较大的值存储在第三个数组中。如果两个值相等，则在第三个数组中存储一个零。在函数结束之前，显示第三个数组中的所有元素。如果两个数组的大小不相等，则显示“无法进行比较”

我所做的就是用蛮力学习ANSI C，但我还是有点迷路

例1： 输入：

arrA[] = {1, 4, 7, 8, 9};
arrB[] = {3, 2, 7, 8, 6};

arrA[] = {1, 2, 3};                          
arrB[] = {2, 4, 5, 7, 9};

输出：

arrC[] = {3, 4, 0, 0, 9};

例2： 输入：

arrA[] = {1, 4, 7, 8, 9};
arrB[] = {3, 2, 7, 8, 6};

arrA[] = {1, 2, 3};                          
arrB[] = {2, 4, 5, 7, 9};

输出：

arrC[] = {3, 4, 0, 0, 9};

---

无法进行比较。

您可以使用名为“sizeof”的函数来进行比较

---

让我们看一看函数，并逐一进行比较，首先也是最重要的，因为比较可能成功（大小相等的数组）或失败（大小不等的数组），所以应该选择一个可以指示成功或失败的返回类型。键入

int

即可，您可以选择您的方案，例如

-1

为失败，

1

为成功，或

0/1

——只要保持一致即可。因此，您的函数原型（假定您希望在函数中填充

arrC[]

，并使填充的

arrC[]

在调用者中可用），您可以执行以下操作：

int cmparrays (int *a, int *b, int *c, size_t sza, size_t szb, size_t szc)
{
    ...

    if (sza != szb || szc < sza) {  /* validate sizes */
        fputs ("Comparison is not possible\n.", stderr);
        return -1;  /* return -1 indicating error */
    }

#include <stdio.h>

int cmparrays (int *a, int *b, int *c, size_t sza, size_t szb, size_t szc)
{
    size_t i;   /* ANSI C requires variable declarations before statements */

    if (sza != szb || szc < sza) {  /* validate sizes */
        fputs ("Comparison is not possible\n.", stderr);
        return -1;  /* return -1 indicating error */
    }

    fputs ("arrC[] = {", stdout);               /* output prefix */

    for (i = 0; i < sza; i++) {                 /* loop over each element */
        if (a[i] == b[i])                       /* if elements equal */
            c[i] = 0;                           /* set to zero */
        else    /* otherwise */
            c[i] = a[i] > b[i] ? a[i] : b[i];   /* set to larger element */
        printf (i ? ", %d" : "%d", c[i]);       /* output value */
    }
    fputs ("};\n", stdout);     /* tidy up with closing brace & newline */

    return 1;   /* return success */
}

int main (void) {
#ifndef TESTUNEQUAL
    int arrA[] = {1, 4, 7, 8, 9},
        arrB[] = {3, 2, 7, 8, 6},
#else
    int arrA[] = {1, 2, 3},
        arrB[] = {2, 4, 5, 7, 9},
#endif
        arrC[sizeof arrA/sizeof *arrA] = {0};
    size_t  sza = sizeof arrA/sizeof *arrA,
            szb = sizeof arrB/sizeof *arrB,
            szc = sizeof arrC/sizeof *arrC;

    if (cmparrays (arrA, arrB, arrC, sza, szb, szc) == -1)
        return 1;
    /* you can use array arrC[] here and below */
}

您提到了ANSI C，这将注入一个额外的警告，因为ANSI C要求在每个作用域的开头声明变量，并且没有在

for

loop语句本身中声明循环变量，因此您需要：

    size_t i;   /* ANSI C requires variable declarations before statements */

第一项任务应该是比较

arrA[]

和

arrB[]

的规模。如果它们不相等，则比较失败，您应该返回错误。作为测试的第二部分，您应该确保

arrC[]

的大小至少与

arrA[]

和

arrB[]

的大小一样大。你可以做：

int cmparrays (int *a, int *b, int *c, size_t sza, size_t szb, size_t szc)
{
    ...

    if (sza != szb || szc < sza) {  /* validate sizes */
        fputs ("Comparison is not possible\n.", stderr);
        return -1;  /* return -1 indicating error */
    }

#include <stdio.h>

int cmparrays (int *a, int *b, int *c, size_t sza, size_t szb, size_t szc)
{
    size_t i;   /* ANSI C requires variable declarations before statements */

    if (sza != szb || szc < sza) {  /* validate sizes */
        fputs ("Comparison is not possible\n.", stderr);
        return -1;  /* return -1 indicating error */
    }

    fputs ("arrC[] = {", stdout);               /* output prefix */

    for (i = 0; i < sza; i++) {                 /* loop over each element */
        if (a[i] == b[i])                       /* if elements equal */
            c[i] = 0;                           /* set to zero */
        else    /* otherwise */
            c[i] = a[i] > b[i] ? a[i] : b[i];   /* set to larger element */
        printf (i ? ", %d" : "%d", c[i]);       /* output value */
    }
    fputs ("};\n", stdout);     /* tidy up with closing brace & newline */

    return 1;   /* return success */
}

int main (void) {
#ifndef TESTUNEQUAL
    int arrA[] = {1, 4, 7, 8, 9},
        arrB[] = {3, 2, 7, 8, 6},
#else
    int arrA[] = {1, 2, 3},
        arrB[] = {2, 4, 5, 7, 9},
#endif
        arrC[sizeof arrA/sizeof *arrA] = {0};
    size_t  sza = sizeof arrA/sizeof *arrA,
            szb = sizeof arrB/sizeof *arrB,
            szc = sizeof arrC/sizeof *arrC;

    if (cmparrays (arrA, arrB, arrC, sza, szb, szc) == -1)
        return 1;
    /* you can use array arrC[] here and below */
}

（它将输出

“arrC[]={”

设置要输出的其余元素）

现在只需在

arrA[]

和

arrB[]

中的元素上循环，如果它们相等，则将

0

分配给

arrC[]

的元素，否则，将较大的元素分配给

arrC[]

。这可以通过一个简单的循环、一个

if…else

和一个

三元

操作符来完成，例如

    for (i = 0; i < sza; i++) {                 /* loop over each element */
        if (a[i] == b[i])                       /* if elements equal */
            c[i] = 0;                           /* set to zero */
        else    /* otherwise */
            c[i] = a[i] > b[i] ? a[i] : b[i];   /* set to larger element */
        printf (i ? ", %d" : "%d", c[i]);       /* output value */
    }

将其放在一个简短的示例中，以测试相等和不相等的数组长度，您可以执行以下操作：

int cmparrays (int *a, int *b, int *c, size_t sza, size_t szb, size_t szc)
{
    ...

    if (sza != szb || szc < sza) {  /* validate sizes */
        fputs ("Comparison is not possible\n.", stderr);
        return -1;  /* return -1 indicating error */
    }

#include <stdio.h>

int cmparrays (int *a, int *b, int *c, size_t sza, size_t szb, size_t szc)
{
    size_t i;   /* ANSI C requires variable declarations before statements */

    if (sza != szb || szc < sza) {  /* validate sizes */
        fputs ("Comparison is not possible\n.", stderr);
        return -1;  /* return -1 indicating error */
    }

    fputs ("arrC[] = {", stdout);               /* output prefix */

    for (i = 0; i < sza; i++) {                 /* loop over each element */
        if (a[i] == b[i])                       /* if elements equal */
            c[i] = 0;                           /* set to zero */
        else    /* otherwise */
            c[i] = a[i] > b[i] ? a[i] : b[i];   /* set to larger element */
        printf (i ? ", %d" : "%d", c[i]);       /* output value */
    }
    fputs ("};\n", stdout);     /* tidy up with closing brace & newline */

    return 1;   /* return success */
}

int main (void) {
#ifndef TESTUNEQUAL
    int arrA[] = {1, 4, 7, 8, 9},
        arrB[] = {3, 2, 7, 8, 6},
#else
    int arrA[] = {1, 2, 3},
        arrB[] = {2, 4, 5, 7, 9},
#endif
        arrC[sizeof arrA/sizeof *arrA] = {0};
    size_t  sza = sizeof arrA/sizeof *arrA,
            szb = sizeof arrB/sizeof *arrB,
            szc = sizeof arrC/sizeof *arrC;

    if (cmparrays (arrA, arrB, arrC, sza, szb, szc) == -1)
        return 1;
    /* you can use array arrC[] here and below */
}

或在定义了

testunquality

的情况下编译：

$ gcc -Wall -Wextra -pedantic -std=c11 -Ofast -o bin/cmparrays_unequal \
cmparrays.c -DTESTUNEQUAL

$ ./bin/cmparrays_unequal
Comparison is not possible

---

如果您还有其他问题，请告诉我。

要获得数组的长度，您需要将要检查的数组的大小除以数组的类型，例如：

int arrA[] = {1, 4, 7, 8, 9};
int sizeOfArrayA = sizeof(arrA)/sizeof(int);

在Sizeofaraya，您将获得5

下面的代码是示例：

int compare(int* arrA, int sizeA, int* arrB, int sizeB, int* arrC){
    int i;
    if(sizeA != sizeB)
        return -1;

    for(i=0;i<sizeA;i++){
        if(arrA[i]==arrB[i])
            arrC[i] = 0;
        else if(arrA[i]>arrB[i])
            arrC[i] = arrA[i];
        else
            arrC[i] = arrB[i];
    }

    return 0;
}

int main(void) {
    int arrA[] = {1, 4, 7, 8, 9};
    int arrB[] = {3, 2, 7, 8, 6};
    int arrC[50] = {0};

    if(compare(
            arrA, sizeof(arrA)/sizeof(int),
            arrB, sizeof(arrB)/sizeof(int),
            arrC) != 0)
    {
        printf("Comparison is not possible.\n");
    }

    return 0;
}

int比较（int*arrA、int-sizeA、int*arrB、int-sizeB、int*arrC）{
int i；
if（sizeA！=sizeB）
返回-1；
对于（i=0；iarrB[i]）
arrC[i]=arrA[i]；
其他的
arrC[i]=arrB[i]；
}
返回0；
}
内部主（空）{
int arrA[]={1,4,7,8,9}；
int arrB[]={3,2,7,8,6}；
int arrC[50]={0}；
如果（比较(
阿拉，sizeof（阿拉）/sizeof（内特），
arrB，sizeof（arrB）/sizeof（int），
arrC）！=0）
{
printf（“无法进行比较。\n”）；
}
返回0；
}

因此您有了

void cmparrays（int*a，int*b，size\t sza，size\t szb）{…}

并且您已经将数组和每个数组的大小传递给了您的函数。（如果需要传入第三个数组，也可以将

int*c，size\t szc

作为参数传递）。现在只需实现您的逻辑。你卡在哪里？显示你的代码（1）你必须事先知道两个数组的大小，以检查它们是否相等。（2） 将数组1、数组2、大小1、大小2传递给函数。（3） 如果（尺寸1！=尺寸2）退出。（4） 从i=0到i=1或2的循环。并比较数组1[i]和数组2[i]。将最大值放入第三个数组。循环完成后，返回第三个数组的起始地址。

sizeof

是运算符，而不是函数。単純に英語を間違えていましたか。修正ありがとうございます。非常感谢您的详细回复。我真的很想经历这一切并理解它。我们在地狱周，所以我可能无法回答一个问题，直到我们完成了考试和东西。再次感谢你。