在C中返回2D char数组

Question

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

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

而已。 相当简单的想法，但想法不能在C中轻松工作。

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

Answer 1

C不会从函数返回数组。

你可以做几件可能足够接近的事情：

• 您可以在struct打包数组并return它。 ç 将返回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)为数组分配的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显示这种设施的“m”和“n”。 它仅显示了一种制作静态2D字符数组的技术，并通过指向数组“字符串”的指针数组的中间函数在函数中处理它。

Answer 4

以下将做你想要的。 它将打印“一”和“十”。 另请注意，它的输入精确到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;
}

Answer 5

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

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

Answer 6

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);
} 

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