C 函数将不打印特定列表

我被要求定义一个函数，它接受一个列表的值，并将其元素分配到两个列表中：一个用于奇数，另一个用于偶数。我创建了函数

array\u oddeven（）

，并向其传递了两个参数：

int*ptr

：指向数组的指针

int length

：表示数组的大小

并在

int main（）中调用它

这是我的代码：
但是我得到了这个输出：
我的错误在哪里？
正如评论中指出的，您的代码并没有达到您可能认为的效果：
返回偶数、奇数使用逗号运算符

事实上，它不会同时返回两个值，而是只返回一个值

如果要检索两个数组，可以将返回值作为函数的输入参数传递；这是我的样子：

void array_oddeven(const int *ptr, int length, int **podd, int **peven){
    /* fill both arrays with 0 as your print function go thru the whole
     * lenght of elements */
    int *even = calloc(length, sizeof(int));
    int *odd = calloc(length, sizeof(int));
    int j=0;
    int k=0;
    for (int i = 0; i < length; i++)
    {
        if (ptr[i] % 2 == 0) {
            even[j] = ptr[i];
            j++;
        } else {
            odd[k] = ptr[i];
            k++;
        }
    }
    *peven = even;
    *podd = odd;
}

int main()
 {
    int *t = array_create(SIZE);
    int *even;
    int *odd;
    array_oddeven(t, SIZE, &odd, &even);
    array_print(t, SIZE);
    array_print(even, SIZE);
    array_print(odd, SIZE);
    free(odd);
    free(even);
    free(t);
    return 0;
}

void数组\u odd偶数（常量int*ptr，int长度，int**podd，int**peven）{
/*当打印函数贯穿整个过程时，用0填充两个数组
*元素长度*/
int*偶数=calloc（长度，sizeof（int））；
int*odd=calloc（长度，sizeof（int））；
int j=0；
int k=0；
for（int i=0；i

值得注意的是，由于您对偶数/奇数元素的数量知之甚少，因此您可能会返回大小为“未知”的数组，因此您可能会以相同的方式传递元素的输出数量：

void array_oddeven(const int *ptr, int length, int **podd, size_t *poddnumelts,
                                               int **peven, size_t *pevennumelts) {
    /* malloc is back here as the array does not require to be filled with
     * zeros as we return the number of elements that were set */
    int *even = malloc(length * sizeof(int));
    int *odd = malloc(length * sizeof(int));
    int j = 0;
    int k = 0;
    for (int i = 0; i < length; i++)
    {
        if (ptr[i] % 2 == 0) {
            even[j] = ptr[i];
            j++;
        } else {
            odd[k] = ptr[i];
            k++;
        }
    }
    *peven = even;
    *pevennumelts = j;
    *podd = odd;
    *poddnumelts = k;
}

int main()
 {
    int *t = array_create(SIZE);
    int *even, *odd;
    size_t oddnumelts, evennumelts;
    array_oddeven(t, SIZE, &odd, &oddnumelts, &even, &evennumelts);
    array_print(t, SIZE);
    array_print(even, evennumelts);
    array_print(odd, oddnumelts);
    free(odd);
    free(even);
    free(t);
    return 0;
}

void数组\u odd偶数（常量int*ptr，int长度，int**podd，大小\u t*poddnumels，
内部**peven，尺寸*PEVENUMELS）{
/*malloc回到这里，因为数组不需要填充
*返回设置的元素数时为零*/
int*偶数=malloc（长度*sizeof（int））；
int*odd=malloc（长度*sizeof（int））；
int j=0；
int k=0；
for（int i=0；i

更一般的方法，你可以考虑把一个数组没有它的大小传递给函数可以被认为是可疑的（在C中），因为以后没有办法“猜测”它，因此是“正常”的。API总是询问数组及其大小。
C中的函数只返回一个值，由于逗号运算符在计算左操作数后丢弃左操作数，然后计算右操作数并将其视为结果，因此这里基本上只返回奇数数组。
\35; include
 #include <stdio.h>
#include <stdlib.h>
#define UPPER_BOUND 8
#define MAX  100
#define SIZE  12
int counteven,countodd;
void array_print(int *ptr, int length) {
    for (int i = 0; i < length; i++) {
        printf("%d ", ptr[i]);
    }
printf("\n");
}

int* array_create(int length) {
int *t = (int*)malloc(length * sizeof(int));
for (int i = 0; i < length; i++) {
    t[i] = rand() % MAX;
   }

return t;
}

int *array_oddeven(int *ptr, int length){
int j=0;
int k=0;
for (int i = 0; i < length; i++)
{
    if (ptr[i] % 2 == 0) {
       counteven++;
    } else {
        countodd++;
    }
}
int *even,*odd;
even = (int*)malloc(counteven * sizeof(int));
odd = (int*)malloc(countodd * sizeof(int));
for (int i = 0; i < length; i++)
{
    if (ptr[i] % 2 == 0) {
       *(even+j)=ptr[i];
       j++;
    } else {
        *(odd+k)=ptr[i];
        k++;
    }
}
array_print(odd, countodd);
array_print(even, counteven);
}

int main()
{
int *t = array_create(SIZE);
int *even;
int *odd;
array_print(t, SIZE);
array_oddeven(t, SIZE);
free(odd);
free(even);
free(t);
return 0;
}

#包括
#定义上界8
#定义最大值100
#定义大小12
int count偶数，count奇数；
无效数组_打印（int*ptr，int长度）{
for（int i=0；i

`
返回偶数、奇数不做你认为它做的…这很好，但是你能解释我如何摆脱排序元素后面的零吗？
void array_oddeven(const int *ptr, int length, int **podd, int **peven){
    /* fill both arrays with 0 as your print function go thru the whole
     * lenght of elements */
    int *even = calloc(length, sizeof(int));
    int *odd = calloc(length, sizeof(int));
    int j=0;
    int k=0;
    for (int i = 0; i < length; i++)
    {
        if (ptr[i] % 2 == 0) {
            even[j] = ptr[i];
            j++;
        } else {
            odd[k] = ptr[i];
            k++;
        }
    }
    *peven = even;
    *podd = odd;
}

int main()
 {
    int *t = array_create(SIZE);
    int *even;
    int *odd;
    array_oddeven(t, SIZE, &odd, &even);
    array_print(t, SIZE);
    array_print(even, SIZE);
    array_print(odd, SIZE);
    free(odd);
    free(even);
    free(t);
    return 0;
}

void array_oddeven(const int *ptr, int length, int **podd, size_t *poddnumelts,
                                               int **peven, size_t *pevennumelts) {
    /* malloc is back here as the array does not require to be filled with
     * zeros as we return the number of elements that were set */
    int *even = malloc(length * sizeof(int));
    int *odd = malloc(length * sizeof(int));
    int j = 0;
    int k = 0;
    for (int i = 0; i < length; i++)
    {
        if (ptr[i] % 2 == 0) {
            even[j] = ptr[i];
            j++;
        } else {
            odd[k] = ptr[i];
            k++;
        }
    }
    *peven = even;
    *pevennumelts = j;
    *podd = odd;
    *poddnumelts = k;
}

int main()
 {
    int *t = array_create(SIZE);
    int *even, *odd;
    size_t oddnumelts, evennumelts;
    array_oddeven(t, SIZE, &odd, &oddnumelts, &even, &evennumelts);
    array_print(t, SIZE);
    array_print(even, evennumelts);
    array_print(odd, oddnumelts);
    free(odd);
    free(even);
    free(t);
    return 0;
}

 #include <stdio.h>
#include <stdlib.h>
#define UPPER_BOUND 8
#define MAX  100
#define SIZE  12
int counteven,countodd;
void array_print(int *ptr, int length) {
    for (int i = 0; i < length; i++) {
        printf("%d ", ptr[i]);
    }
printf("\n");
}

int* array_create(int length) {
int *t = (int*)malloc(length * sizeof(int));
for (int i = 0; i < length; i++) {
    t[i] = rand() % MAX;
   }

return t;
}

int *array_oddeven(int *ptr, int length){
int j=0;
int k=0;
for (int i = 0; i < length; i++)
{
    if (ptr[i] % 2 == 0) {
       counteven++;
    } else {
        countodd++;
    }
}
int *even,*odd;
even = (int*)malloc(counteven * sizeof(int));
odd = (int*)malloc(countodd * sizeof(int));
for (int i = 0; i < length; i++)
{
    if (ptr[i] % 2 == 0) {
       *(even+j)=ptr[i];
       j++;
    } else {
        *(odd+k)=ptr[i];
        k++;
    }
}
array_print(odd, countodd);
array_print(even, counteven);
}

int main()
{
int *t = array_create(SIZE);
int *even;
int *odd;
array_print(t, SIZE);
array_oddeven(t, SIZE);
free(odd);
free(even);
free(t);
return 0;
}