我应该如何malloc/realloc包含一个数组的结构？

Question

我对c很新，所以如果我的步骤有误，请告诉我。比方说，我有类似以下内容：

struct graphNode{ 
    int val; 
    graphNode* parent; 
    int succSize; 
    int succMaxSize; 
    graphNode* succ[1]; 
}; 

我将创建一个新的节点：

graphNode *n; 
n = malloc(sizeof(struct graphNode)); 
assert(n); 
n->val = 1; 
n->parent = NULL; 
n->succSize = 0; 
n->succMaxSize = 1; 

然后，如果我想给继任添加到节点

if (n->succSize == n->succMaxSize){ 
    n->succ = realloc(n->succ, sizeof(graphNode*) * n->succMaxSize * 2); 
    n->succMaxSize *= 2; 
} 
n->succ[succSize] = n2; //n2 is of type graphNode* 
succSize++; 

这是正确的吗？我是否需要重新分配结构体，或者是否足够重新分配数组？我需要对初始数组使用malloc吗？初始数组的大小应该包含在我的malloc调用中吗？

Answer 1

的通常方法在C中定义了“有弹性的”阵列构件是要么指定大小的0或没有大小在所有，例如：

struct foo { 
    int stuff; 
    bar theBars[]; // or theBars[0] 
}; 

在这个定义下，sizeof(struct foo)将包括所有元素除了最后的数组之外，您可以通过说malloc(sizeof(struct foo) + numberOfBars * sizeof(bar))来分配正确的大小。

如果您需要重新分配它以更改bar元素的数量，那么您将使用相同的公式（但使用新的numberOfBars）。

要清楚，你不能只是realloc结构的一部分。你必须realloc整个事情。

Answer 2

如果你只想要一个单一的数组，只需使用一个指针succ，并且只使用malloc/realloc等来为数组分配内存。

graphNode* succ; 

你在做什么几乎肯定会中断。

Answer 3

我也是C新手，但有一些东西我可以直接看到蝙蝠。首先，你不能重新分配数组。在c89中，它们是编译时固定大小的。在C99和C11中，它们可以动态分配，但不能重新分配（据我所知）。所以对此，您需要分配一个指针和malloc（节点* sizeof（节点））

graphnode *succ; 

。

graphNode* succ[1]; 

这会创建一个大小为1的数组，而不是一个最大索引为1的数组。因此，它是相同的（几乎）功能作为

graphNode* succ; 

只是一旦你做它，你不能改变它的大小。

我想你想要的是做一个树，动态重新分配数量的分支。在这种情况下，只需要重新分配graphNode *指针的大小，然后像索引数组那样通过索引访问每个元素。

Answer 4

realloc(ptr,size)需要2个参数，而不是1，在realloc(sizeof(graphNode*) * n->succMaxSize * 2)

// Something like ... 
graphNode *n; 
n->succSize = 0; 
n->succMaxSize = 0; // set to 0 
n->succ = NULL; // Initialize to NULL 

// Then, if OP wants to add a successor to the node 
if (n->succSize <= n->succMaxSize){ 
    n->succ = realloc(n->succ, sizeof(graphNode*) * n->succMaxSize * 2); 
    n->succMaxSize *= 2; 
} 
n->succ[succSize++] = n2; 

---

用作与所有的内存分配，检查NULL回报。在realloc()中，应保存原始值，因此如果realloc()失败，原始指针不会丢失。

Answer 5

通常，当您看到struct定义中最后一个字段是大小为0或1的数组时，这意味着作者将在malloc绑定时使用malloc做一些细微的事情。

例如

struct foo { 
    int x; 
    : 
    : 
    type a[0]; 
}; 

随着一个malloc像

struct foo *p = malloc(sizeof(*p) + (n * sizeof(type)); 

这样做什么是它分配一个连续的内存块的结构和尾随阵列。在这种情况下，数组大小为n。因此，在这种情况下对阵列的引用是：

p->a[i] // where i >= 0 and i < n 

这样做的一个原因是为了节省内存。

我相信在StackOver上有更好的解释。这是一个非常普通的C语言。

当数组是动态时，通常不使用它。相反，它在malloc（）时已知数组大小时使用。当然，您可以动态使用，但您必须重新分配整个内存块，而不仅仅是自己的结构或数组。要增加到2n的大小，你会说

p = realloc(p, sizeof(*p) + (2 * n * sizeof(type))); 

现在你的数组是两倍大，因为它仍然是一块内存。