是否可以将 char[][] 传递给请求 char** 的函数？

Question

我正在尝试调用一个以 char** 作为参数的函数。它的工作是填充字符串数组（即 char* 数组）。我知道字符串的最大长度，我可以将要填充的最大数量作为另一个参数传递，所以我希望像这样堆栈分配它：

fill_my_strings(char** arr_str, int max_str); // function prototype

char fill_these[max_strings][max_chars_per_string]; // allocating chars
fill_my_strings(fill_these, max_strings); // please fill them!

当然，我收到“无法将 char[max_strings][max_chars_per_string] 转换为 char**”错误。

我知道这是一些微妙（或不那么微妙）的问题，因为我对数组和指针之间的区别的理解。我只是不确定为什么不能将这块内存传递给想要一个 char** 的东西并让它填充我的堆栈分配的字符。有人可以解释一下这是否可行，如果不可行，为什么不呢？

不调用malloc/new可以调用这样的函数吗？

Answer 1

您的问题的简单答案是否定的；二维数组不同于指向指针的指针类型。数组衰减指向指向它们的第一个元素的指针，但实际上指针是那个值。

如果将两者都转换为char*，这些类型之间的区别就很明显了

int x;
char *arr_pp[] = {"foo", "bar", "baz"};
char arr_2d[][4] = {"foo", "bar", "baz"};

char *cp = (char*)arr_pp;
for(x=0; x<3; x++)
     printf("%d ", cp[x]);
printf("\n");

cp = (char*)arr_2d;  
for(x=0; x<3; x++)
     printf("%d ", cp[x]);
printf("\n");

输出（在我的电脑上）是：

-80 -123 4 
102 111 111 

第一行是乱码，因为我正在打印一个转换为字节的地址，第二行是“foo”的 ascii 值。

在采用char ** 的函数中，编译器无法知道衰减数组类型，这些类型实际上并不包含指针。

Answer 2

我不确定为什么 fill_my_strings() 需要 char** 参数。从您的示例中，调用者已经从堆栈中分配了内存。所以使用char* 应该没问题。

但是如果你想使用char**或者你不能修改fill_my_strings()函数，试试下面的示例代码：

void fill_my_strings(char** arr_str, int max_chars_per_string, int max_strings)
{

    for(int i = 0; i < max_strings; ++i)
    {
        //Make sure you have enough space
        memcpy(*arr_str, "ABCD", sizeof("ABCD"));

        *arr_str += max_chars_per_string;
    }
}

char fill_these[max_strings][max_chars_per_string];
char* pointer = (char*)fill_these;
fill_my_strings(&pointer, max_strings, max_chars_per_string);

Answer 3

假设您有 n 个指向最多 m-1 个字符的字符串（包括 NULL 的 m 个字符）的指针。 因此，在纯 C 中： sizeof(char[n][m]) 将返回 n*m。 sizeof(char**) 将返回架构中指针的大小，可能是 32（如果 x86）或 64（如果 x86_64）。

char[n][m] 实际上是连续分配 n*m 字节。 char** 分配一个指针。此指针引用 *n 字节的内存条。这 n 个指针中的每一个都指向一个由 m 个字符组成的内存条。

所以，考虑到 sizeof(char) == u，如果你声明 char a[n][m]，当你使用 a[i][j] 时，编译器会理解 *(a + i*m*u + j*u)。 所以，考虑到sizeof(char *) == w，如果你声明char **a，当你使用a[i][j]时，编译器会理解((a + i*w) + j*w)。

完全不同的数据管理。

处理特殊情况的关闭方法是创建一个 char** 变量，并使用堆栈分配矩阵的地址填充它。

char **tmp = malloc(max_strings * sizeof(char *));
int i;
for(i = 0; i < max_strings; i++){
    tmp[i] = &(fill_these[i][0]); //you probably can't reference a char[][] with a single index - not confirmed
}

Answer 4

显而易见的事情就是建立一个索引

在 c 中使用类似的东西：

char string_list[num_strings][str_length];

// ...

char**index = calloc( (num_strings+1), sizeof(*index) ); // calloc insures NULL termination
for (int i=0; i<num_strings; ++i) {
   index[i] = string_list[i]
}

在 c++ 中，new[] 优于 calloc；