Question

我搞砸了这个，但我真的不明白。

以下是我想要做的事情：将2D char数组作为函数的输入，更改其中的值，然后返回另一个2D char数组。

那就是它。非常简单的想法，但想法不能在C中轻松工作。

让我以最简单的形式开始的任何想法都值得赞赏。感谢。

Answer 1

C不会从函数返回数组。

你可以做一些可能足够接近的事情：

您可以将数组打包到struct和return。 C 将从函数中返回struct就好了。缺点是这可能会有很多内存来回复制：

struct arr {
    int arr[50][50];
}

struct arr function(struct arr a) {
    struct arr result;
    /* operate on a.arr[i][j]
       storing into result.arr[i][j] */
    return result;
}

您可以将指针返回到阵列。此指针必须指向您为数组分配malloc(3)的内存。（或另一个不从堆栈分配内存的内存分配原语。）
```
int **function(int param[][50]) {
    int arr[][50] = malloc(50 * 50 * sizeof int);
    /* store into arr[i][j] */
    return arr;
}
```

您可以对传入函数的数组指针进行操作，然后修改输入数组。

void function(int param[][50]) {
    /* operate on param[i][j] directly -- destroys input */
}

您可以将参数用作“输出变量”，并使用它来“返回”新数组。如果您希望调用者分配内存或者您想要指示成功或失败，那么这是最好的：

int output[][50];

int function(int param[][50], int &output[][50]) {
    output = malloc(50 * 50 * sizeof int);
    /* write into output[i][j] */
    return success_or_failure;
}

或者，为调用者分配：

int output[50][50];

void function(int param[][50], int output[][50]) {
    /* write into output[i][j] */
}

Answer 2

您无法从函数返回数组。

您有几种选择：

将数组包装在结构

struct wraparray {
    int array[42][42];
};

struct wraparray foobar(void) {
    struct wraparray ret = {0};
    return ret;
}

将目标数组作为指向其第一个元素（及其大小）的指针传递给函数;并更改该数组

int foobar(int *dst, size_t rows, size_t cols, const int *src) {
    size_t len = rows * cols;
    while (len--) {
        *dst++ = 42 + *src++;
    }
    return 0; /* ok */
}

// example usage
int x[42][42];
int y[42][42];
foobar(x[0], 42, 42, y[0]);

更改原始数组

int foobar(int *arr, size_t rows, size_t cols) {
    size_t len = rows * cols;
    while (len--) *arr++ = 0;
    return 0; /* ok */
}

Answer 3

这是另一个例子。经过测试和工作。

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

void test(char**,unsigned int,unsigned int);

const unsigned int sz_fld = 50 + 1;
const unsigned int sz_ffld = 10;

int main(void) {
    char fld[sz_ffld][sz_fld];
    for (unsigned char i=0;i<sz_ffld;++i) {
        strcpy(fld[i],"");
    }

    strcpy(fld[0],"one");
    strcpy(fld[1],"two");
    strcpy(fld[2],"three");

    char** pfld = malloc(sz_ffld*sizeof(char*));
    for (unsigned int i=0;i<sz_ffld;++i) {
        *(pfld+i) = &fld[i][0];
    }

    test(pfld,sz_ffld,sz_fld);

    printf("%s\n",fld[0]);
    printf("%s\n",fld[1]);
    printf("%s\n",fld[2]);

    free(pfld);

    return(0);
}

void test(char** fld,unsigned int m,unsigned int n) {
    strcpy(*(fld+0),"eleven");
    strcpy(*(fld+1),"twelve");
    return;
}

请注意以下事项：

对于编译，我使用gcc和C99选项。

我定义了函数包含两个大小的信息，但是我编写了非常基本的代码，实际上并没有使用这些信息，只是strcpy（），所以这肯定不是安全性代码（甚至虽然我正在展示这种设施的“m”和“n”。它仅显示了一种制作静态2D char数组的技术，并通过指向数组“字符串”的指针数组的中间函数在函数中处理它。

Answer 4

当您将2D数组作为参数传递给函数时，您需要明确告诉它第二维数组的大小

void MyFunction(array2d[][20]) { ... }

Answer 5

char **foo(const char * const * bar, size_t const *bar_len, size_t len0) {
    size_t i;        
    char** arr = malloc(sizeof(char *) * len0);
    for (i = 0; i < len0; ++i) {
        arr[i] = malloc(bar_len[i]);
        memcpy(arr[i], bar[i], bar_len[i]);
    }
    /* do something with arr */
    return arr;
}

代码中的其他地方：

char **pp;
size_t *pl;
size_t ppl;
/* Assume pp, pl are valid */
char **pq = foo(pp, pl, ppl);
/* Do something with pq */
/* ... */
/* Cleanup pq */
{
    size_t i;
    for (i = 0; i < ppl; ++i)
        free(pq[i]);
    free(pq);
}

因为您通过指针而不是按值传递并且您想要写入输入数组，所以您必须复制它。

Answer 6

以下将做你想要的。它将打印“一”和“十”。另请注意，它的输入类型为10和8的精确数组。

char my_array[10][8] = 
{
{"One"},
{"Two"},
{"One"},
{"One"},
{"One"},
{"One"},
{"One"},
{"One"},
{"Nine"},
{"Ten"},
};

void foo ( char (**ret)[10][8] )
{
  *ret = my_array;
}

void main()
{
  char (*ret)[10][8];
  foo(&ret);

  printf("%s\r\n", (*ret)[0] )
  printf("%s\r\n", (*ret)[9] )
}

最初的问题是关于RETURNING数组，所以我正在更新它以显示返回值。你不能直接“返回一个数组”，但你可以创建一个数组的typedef并返回...

char my_array[10][8];
typedef char ReturnArray[8];
ReturnArray* foo()
{
  return my_array;
}

在C中返回2D char数组

6 个答案: