c-使用realloc和calloc增加函数内部2D数组的大小

Question

我想在一个数组中存储多个字符串(也称为字符数组(。因此，我想使用2D阵列。由于我不知道确切的大小(既不知道单个字符串的长度也不知道字符串的数量(，我需要动态地增加大小。

为了更好的结构，我想把这个放在一个单独的函数里面。然而，如果我在调整数组大小后访问它，显然大小没有改变，并且我会出现分段错误。

我是C的新手(来自C++背景(

#include<stdio.h>
#include <stdlib.h>
//I want to increase my array from [1][5] to [2][5]
void increase(char*** data)
{
*data = realloc(*data, 2 * sizeof (char*));
*data[1] = calloc(5, sizeof(char));
}
int main(void)
{
char** data  = calloc(1, sizeof(char*));
data[0] = calloc(5, sizeof(char));
increase(&data);
data[1][3] = 'a'; //<-- When I access the array I get an segmentation fault
free(data);

return 0;
}

我使用char***的方法正确吗？我可以在测试环境中直接在主函数中实现它，它起作用了。但是，一旦把它封装在一个函数中，我就得到了一个seg。过错

我认为这与我将数组传递给函数的方式有关，但我不知道这是什么原因以及如何解决。有人有什么想法或解决方案吗？

Answer 1

错误(这是一个微妙的灾难性错误(在于您试图如何分配传递的指针数组的第二个元素，并且与运算符优先级有关。请注意，数组下标运算符[]的优先级高于间接运算符*。

因此，您的产品线：

*data[1] = calloc(5, sizeof(char));

实际上具有以下效果：

*(data[1]) = calloc(5, sizeof(char));

正如你所希望看到的，这真的是你想要做的而不是

相反，您需要：

(*data)[1] = calloc(5, sizeof(char));

另一个问题(虽然不是错误，本身(是您没有对分配进行任何错误检查；在使用realloc时，这一点尤为重要，因为就代码而言，如果调用失败，将丢失"原始"指针。最好将realloc的返回值存储在临时中，然后仅当该临时不是NULL时才覆盖原始值。

以下是对代码的可能重新处理(不过，您可以/应该在calloc调用上添加更多的错误检查(：

#include <stdio.h>
#include <stdlib.h>
int increase(char*** data)
{
char** temp = realloc(*data, 2 * sizeof(char*));
if (temp != NULL) {
*data = temp;   // Only overwrite the original if we succeed!
(*data)[1] = calloc(5, sizeof(char));
return 1;
}
else {
printf("Allocation error!"); // But we still have our original "data" pointer
return 0;
}
}
int main(void)
{
char** data = calloc(1, sizeof(char*));
data[0] = calloc(5, sizeof(char));
if (increase(&data)) {
data[1][3] = 'a';
printf("%cn", data[1][3]); // Just to do some testing!
free(data[1]); // Free the second (added) block
}
free(data[0]) // Free the first (original) block
free(data); // "data" will be valid whether or not our call to "increase" works
return 0;
}

Answer 2

1. 指针的纯代码数组中没有任何2D数组。你的问题是关于2D阵列的

琐碎代码(列数不变(

void *alloc2D(const size_t rows, const size_t cols, char (*arr)[cols])
{
arr = realloc(arr, rows * sizeof(*arr));
return arr;
}

不那么琐碎的代码-两者都在变化。

void *alloc2D(const size_t rows, const size_t cols, const size_t oldrows, const size_t oldcols, char (*arr)[oldcols])
{
char (*newarr)[cols] = malloc(rows * sizeof(*newarr));
if(arr && newarr)
{
for(size_t r = 0; r < rows && r < oldrows; r++)
{
memcpy(newarr[r], arr[r], sizeof(*arr) > sizeof(*newarr) ? sizeof(*newarr) : sizeof(*arr));p
}
}   
if(newarr) free(arr);
return newarr;
}

还有一些用法：

void *increase(const size_t oldrows, const size_t oldcols, char (*arr)[oldcols])
{
return alloc2D(oldrows+1, oldcols, arr);
}
int main(void)
{
size_t rows;
size_t cols;
if(scanf("%zu", &rows) != 1) { /* error handling*/}
if(scanf("%zu", &cols) != 1) { /* error handling*/}
char (*arr)[cols] = alloc2D(rows, cols, NULL);
char (*narr)[cols];
narr = increase(rows, cols, arr);
if(narr) arr = narr;
free(narr);

return 0;
}