0

这个问题可能看起来非常简单，但是我如何在 c 中声明一个返回双精度数组的函数。例如

char myfunction(int a, int b)
{
...
char d[a][b];
...
return d;
}

但这似乎不起作用（如果响应可以避免“malloc”和“free”的用法，那么理解这些基本用法可能会更有帮助）

最好的，纽本

4

4 回答 4

3

但这似乎不起作用（如果响应可以避免“malloc”和“free”的用法，那么理解这些基本用法可能会更有帮助）

好吧，你不能因为你提议返回一个一旦函数返回就无效的指针。该数组被声明为具有自动存储持续时间，因此，一旦函数返回，对它的所有引用都将无效。您不能从 C 中的函数返回数组。

如果您需要在函数中填充数据，则可以从函数中返回char**一个malloc。

char **foo(int cols, int rows) {
  char **ret = malloc(rows * sizeof(char*));
  if(!ret)
    return ret;

  for(int i = 0; i < rows; ++i) {
    ret[i] = malloc(cols);
    /* error checking again for malloc,
       call free() on pointers 0...i upon failure.
       memset to 0 if you like */
  }

  return ret;
}

您现在可以对返回值使用多维数组语法。

char **p = foo(10, 20);

// p[j] returns a pointer to char, p[j][k] returns a char
char elem = p[j][k];
于 2012-07-23T20:04:07.563 回答
1

在这种情况下，您无法避免 malloc 和 free。问题是通过声明

char d[a][b];

您直接在堆栈上分配一个数组，因此当您的函数返回时，数组被取消分配并且您返回的地址无效。

使用类似的东西：

char** myfunction(int a, int b) {
    char** d = (char**)malloc(a * sizeof(char*));

    if (d ! = NULL) {
        for (int i = 0; i < b; i++) {
            d[i] = (char*)malloc(sizeof(char));

            if (d[i] == NULL) {
                for (int j = 0; j < i; j++) {
                    free(d[j]);
                }

                free(d);
                d = NULL;

                break;
            }
        }
    }

    return d;
}
于 2012-07-23T20:06:44.147 回答
1

在 C 中，如果您希望一个函数创建一个数组并将其返回给它的调用者，您必须使用malloc或另一个动态分配内存的函数（例如callocor realloc）。然后，您可以返回指向该数组的指针。

char **make2dArray(int x, int y) {
    int i;
    char **array = calloc(x, sizeof(char*));
    for(i = 0; i < x; i++) {
        array[i] = calloc(y, sizeof(char));
    }
    return array;
}

另一方面，如果您只是需要修改数组的值，最好将数组作为参数并在原地修改。

void modify2dArray(int x, int y, char **array) {
    int i, j;
    for(i = 0; i < x; i++) {
        for(j = 0; j < y; j++) {
            array[i][j] = 1;
        }
    }
}

请记住，一旦您完成了动态分配的内存，请为每个分配调用 free ：

void dealloc2dArray(int x, int y, char **array) {
    int i;
    for(i = 0; i < x; i++) {
        free(array[i]);
    }
    free(array);
}

以下是使用这些函数的样子：

char **array = NULL;
array = make2dArray(5,6);
modify2dArray(5,6,array);
dealloc2dArray(5,6);
array = NULL;

请注意，动态分配函数（malloc、calloc和realloc）可能会失败，返回 NULL。我没有在每次分配后检查 NULL 以节省空间，但确保分配成功通常是一种好习惯。

于 2012-07-23T20:15:44.660 回答
1

自 C99 以来，在 C 中，分配真实二维数组的正确方法，而不是其他答案中的仿真，是执行以下操作：

char (*array)[cols] = malloc(cols * rows);

如果你必须在一个函数中这样做，对我来说最简单的方法似乎是

void * foo(int cols, int rows) {
  char (*ret)[cols] = malloc(rows * cols);
  // do something with it
  return ret;
}

调用它时，您必须更加小心地将维度赋予新变量

char (*array)[cols] = foo(cols, rows);

所有这些都具有一个优点，即一个简单malloc的用于分配一个连续的对象，并且您只需要free在最后进行一次调用即可释放内存。

于 2012-07-23T21:31:48.083 回答