Question

我正在尝试返回4个指针，这些指针存储在来自C中函数的另一个指针中，但是我得到了分段错误。有谁知道怎么做？

这就是我尝试这样做的方式：

//declaration of 5 pointers (int * ptr0, float * ptr1, ..., int * ptr4)

int * function()
{
    int * ptr;
    ptr = malloc(sizeof(int)*4);

    float * ptr1;
    ptr1 = malloc(sizeof(float)*4);

    float * ptr2;
    ptr2 = malloc(sizeof(float)*4);

    float * ptr3;
    ptr3 = malloc(sizeof(float)*4);

    int * ptr4;
    ptr4 = malloc(sizeof(int)*4);

    retunr ptr;
}

ptr0 = function();
ptr1 = ptr0[0];
ptr2 = ptr0[1];
//and so on...

好的，我改变了我的程序，但现在我不能再写指针了。我知道这是一个非常“愚蠢”的问题，但我真的不知道。有人可以帮忙吗？

Answer 1

您只能从函数返回单值。一个简单的解决方案是返回包含所需指针的结构。

struct pointers {
    float* ptr1;
    float* ptr2;
    float* ptr3;
    // or perhaps an array instead:
    // float* f_ptrs[3];
    int*   ptr4;
}

struct pointers function() {
    struct pointers p;
    // initialize the members here
    return p;
}

Answer 2

void ** function()
{
    void ** ptr;
    ptr = (void **)malloc(sizeof(void *)*4);

    ptr[0] = malloc(sizeof(float)*4);
    ptr[1] = malloc(sizeof(float)*4);
    ptr[2] = malloc(sizeof(float)*4);
    ptr[3] = malloc(sizeof(int)*4);

    return ptr;
}

Answer 3

有三种选择，你可以返回一个void**（基本上是一个指向你随后投射的void*数组的指针），你可以声明一个包含指针的结构，然后分配和返回指向这样一个结构的指针（然后让调用者取消分配结构）或者你可以使用func(float **ptr0, float **ptr1, float **ptr2, int **ptr3)并将你的malloced内存分配给*ptr0，...

这些都不是完美的，取决于我会选择解决方案2或解决方案3的情况，因为它最终会弄乱所有相关的演员阵容，并允许编译器帮助你输入类型是一个好主意

Answer 4

你没有填写* ptr，但即使你这样做，也不要这样做。使用std::tuple<>或std::pair<>对 - 或返回结构。

编辑：因为它不再是C ++，只需返回一个包含四个字段的结构。

Answer 5

我看到它没有被提及，但你也可以将双指针传递给函数并让函数填充它们，这是另一种返回多个值的方法：

void function(int** p1, float** p2, float** p3, float** p4, int** p5)
{
    *p1 = malloc(sizeof(int)*4);

    *p2 = malloc(sizeof(float)*4);

    *p3 = malloc(sizeof(float)*4);

    *p4 = malloc(sizeof(float)*4);

    *p5 = malloc(sizeof(int)*4);
}

int* ptr1;
float* ptr2;
float* ptr3;
float* ptr4;
int* ptr5;

function(&ptr1, &ptr2, &ptr3, &ptr4, &ptr5);

Answer 6

这个怎么样：

#include <stdlib.h>
#include <stdio.h>  /* for perror() */


int function(void ** ptrs, size_t n)
{
  int result = -1;

  pptrs[0] = malloc(...);
  if (NULL == ptrs[0])
  {
    goto err;
  }

  ...

  ptrs[n - 1] = malloc(...);
  if (NULL == ptrs[n - 1])
  {
    goto err;
  }

  result = 0;

err:

  return result;
}

int main(void)
{
  size_t n = 5;
  void * ptrs[n];
  for (size_t i = 0; i < n; ++n)
  {
    ptrs[n] = NULL;
  }

  if (-1 == function(ptrs, n))
  {
     perror("function() failed");
     exit(EXIT_FAILURE);
  }

  /* Do stuff. */

  /* Free memory where ptrs' are pointing to. */

  return EXIT_SUCCESS;
}

如果不支持VLA，请将main()的开头更改为：

#define N (5)

int main(void)   
{
  size_t n = N;
  void * ptrs[N] = {0};

  if (-1 == function(ptrs, n))
  {
    ...

从函数返回多个指针

6 个答案: