Question

我必须用签名

编写一个函数

 int *greater (int n[], int length, int value)

返回指向包含n []中元素大于值的数组的指针。返回的数组必须完全是保持值大于value的长度，并且没有未使用的元素。

我有以下代码：

#include <stdio.h>

int k=0, v[100];

int * greater(int n[], int length, int value)
{
    for (int i=0; i<length-1; i++)
        if (n[i]>value)
        {
            v[k]=n[i];
            k++;
        }
    int *p=v;
    return p;
}
int main ()
{
    int a[]={1,2,3,4,5};
    int *p=greater (a,5,3);
    int *end; end=v+k;
    while (p<=end)
    {
        printf ("%i ", *p);
        p++;
    }
}

问题是p只会保持4的值，因此它会打印4 0而不是4 5.任何想法我做错了什么？

Answer 1

要解决您的问题，请不要使用全局数组（v[100];）。相反，

在greater()
使用malloc()动态分配内存。
使用realloc()
返回指针。

根据 @alk 先生的评论，您可以使用全局变量k获取数组中的元素数。

注意：一旦您使用了内存，请不要忘记main()指针free()。

顺便说一句，main()的推荐签名是int main(void)

编辑：

此外，对于逻辑部分，如 @BLUEPIXY 和 @karma_geek 的评论中所述，请注意

将循环条件更改为for (int i=0; i<length; i++)
将while循环更改为while (p<end)

Answer 2

除了已经提到的更改之外，我建议进行2次更改：

将for loop迭代到<length，因为<legnth-1不会覆盖整个数组。

int * greater(int n[], int length, int value)
{
    for (int i=0; i<length; i++)
        if (n[i]>value)
        {
            v[k]=n[i];
            k++;  // increment
        }
    int *p=v;
    return p;
}

另外，更改结束的公式。这是因为在函数中，增量发生时，k=0将更改为k=1的{{1}}，4 > 3的{{1}}。现在，

k=2

会导致5 > 3，而我们想要一个较小的值。

end = v + k ;

Code with correct output

Answer 3

由于规范不需要返回目标数组的大小，在函数内部分配一个新数组会使指针返回安静无用，因为调用者不知道哪些元素（如果有的话）是有效的。

所以唯一合理的方法是不为目标分配内存，甚至不使用第二个数组。这也不是规范要求，因此您可能希望采用以下方法

对输入进行排序。
通过简单地循环结果从1 ..
将指针返回到2中找到的元素。

示例：

#include <qsort.h>

int cmp(const void * pv1, const void * pv2)
{
  int i1 = *((int *) pv1);
  int i2 = *((int *) pv2);

  return (i1 - i2);
}

int * greater(int n[], int length, int value)
{
  qsort(n, sizeof *n, length, cmp);

  while (0 < length)
  {
    --length;
    if (n[length] > value)
    {      
      break;
    }
  }

  return n + length + 1;
}

唯一的要求/

返回的
数组必须正好是保持值大于值
的长度

满足。

Answer 4

修改搜索功能以返回指针参数中找到的元素数。在函数中分配结果数组，最小化函数中可能的分配数量，在返回之前收缩结果数组。

例如：

#include <stdio.h>
#include <stdlib.h>

int *
greater(
        const int const n[],
        const size_t n_elem,
        const int threshold,
        size_t *n_greater
        )
{
    size_t i = 0;
    size_t n_found = 0;
    size_t n_allocated = 0;
    int *ret = NULL;

    for (i = 0; i < n_elem; i += 1) {
        if (n[i] > threshold) {
            n_found += 1;
            if (n_found > n_allocated) {
                size_t new_size = (n_allocated < (n_elem / 2))
                                ? 2 * n_found
                                : n_elem
                ;
                int *tmp = realloc(ret, new_size * sizeof(*tmp));
                if (!tmp) {
                    fputs("Failed to allocate memory", stderr);
                    exit(EXIT_FAILURE);
                }
                n_allocated = new_size;
                ret = tmp;
            }
            ret[n_found - 1] = n[i];
        }
    }
    if (n_allocated > n_found) {
        int *tmp = realloc(ret, n_found * sizeof(*tmp));
        if (!tmp) {
            fputs("Failed to shrink result array", stderr);
            exit(EXIT_FAILURE);
        }
        ret = tmp;
    }
    *n_greater = n_found;
    return ret;
}

int main (void)
{
    int a[] = {1,2,3,4,5,1,1,2,3,7,6,5,5,0,-1,7};
    size_t n_greater_than_three = 0;
    size_t i =0;
    int *p = greater(a, sizeof(a)/sizeof(a[0]), 3, &n_greater_than_three);

    for (i = 0; i < n_greater_than_three; i += 1) {
        printf("%d\n", p[i]);
    }

    free(p);

    return EXIT_SUCCESS;
}

输出：

C:\...\Temp> greater.exe
4                                             
5                                             
7                                             
6                                             
5                                             
5                                             
7

C - 返回指向数组的指针

4 个答案: