用于创建 2 个结构的单个 malloc

Question

我有一个具有这种结构的节点：

struct node
{
    unsigned long key;
    unsigned long value;
    struct node* lChild;    
    struct node* rChild;   
};

我有一个具有默认值的虚拟节点：

struct node* newSpecialNode()
{
    struct node* node = (struct node*) malloc(sizeof(struct node));
    node->key = 0;
    node->value = 0;
    node->lChild = NULL;
    node->rChild = NULL;
    return(node);
}

我的数据结构中的所有节点都会调用这个方法来创建一个节点。

struct node* newInternalNode(unsigned long key, unsigned long value)
{
    struct node* node = (struct node*) malloc(sizeof(struct node));
    node->key = key;
    node->value = value;
    node->lChild = newSpecialNode();
    node->rChild = newSpecialNode();
    return(node);
}

我为左右孩子调用函数newSpecialNode()。 所以有两个malloc 调用。但是每当我创建一个节点时，我总是会创建两个虚拟节点。 所以我想做一个为lChild 和rChild 分配内存的malloc。 可能分配一个双字并引用它的部分。但我不知道该怎么做。

我尝试了这种方法。但是我又需要做两个 malloc。

struct node** ptrToTwoNodes = (struct node**) malloc(2*sizeof(struct node*));
ptrToTwoNodes[0] = (struct node*) malloc(sizeof(struct node));
ptrToTwoNodes[1] = (struct node*) malloc(sizeof(struct node));

Answer 1

虽然从技术上讲，您可以使用单个 malloc() 分配所有三个节点，但您确实不应该这样做，因为它破坏了树结构的递归“对称性”。

当调用malloc() 三次时，你会得到一棵树，其中每个节点都是相互独立的。这意味着您可以在以后更改树（添加和删除节点），而不必担心子节点是如何分配的。

问题的根源在于您不能将内存段的free() 部分返回我的malloc()。对于malloc() 返回的每个指针，您总是必须只调用一次free() - 不多也不少。

如果 malloc 对您来说过于昂贵，那么另一种方法是创建一组辅助函数来保存节点结构池（因此它们一次分配 N，然后一个接一个地返回，直到池用完）。见object pool pattern。

Answer 2

如果你想为两个节点分配一块内存，试试

struct node* ptrToTwoNodes = (struct node*) malloc(2*sizeof(struct node));

那么&ptrToTwoNodes[0] 和&ptrToTwoNodes[1] 将是指向你的两个节点的指针。顺便说一句，我猜你应该删除 C++ 标签。

Answer 3

您可以为2个节点分配内存，并将指针分配给一个变量：

struct node* ptrToTwoNodes = (struct node*) malloc(2*sizeof(struct node));
ptrToTwoNodes[0].value = ...;
ptrToTwoNodes[1].value = ...;

Answer 4

我不确定你的最终结果是什么，但你可以这样做：

struct node
{
    unsigned long key;
    unsigned long value;
    struct node* Child;    //allocate two 2 node sized blocks for it & access left-Child[0], right-Child[1]
};

并初始化为：

struct node* newSpecialNode()
{
    struct node* node = (struct node*) malloc(sizeof(struct node));
    node->key = 0;
    node->value = 0;
    node->Child = NULL;
    return(node);
}

然后像这样分配：

struct node* newInternalNode(unsigned long key, unsigned long value)
{
    struct node* node = (struct node*) malloc(sizeof(struct node));
    node->key = key;
    node->value = value;
    node->Child = malloc(sizeof(sruct node)*2); //Child[0] & Child[1] 
    return(node);
}

Answer 5

修改代码如下：

struct node * newSpecialNode(void)
{
  struct node * node = malloc(2 * sizeof(*node));
  node->key = 0;
  node->value = 0;
  node->lChild = NULL;
  node->rChild = NULL;
  ++node;

  node->key = 0;
  node->value = 0;
  node->lChild = NULL;
  node->rChild = NULL;
  --node;

  return node;
}

struct node * newInternalNode(unsigned long key, unsigned long value)
{
  struct node * node = malloc(sizeof(*node));
  node->key = key;
  node->value = value;
  node->lChild = newSpecialNode();
  node->rChild = node->lChild + 1; 

  return node;
}

注意如何free() 事情。

还为所有malloc()s 添加错误检查。

还有^2：In C there is no need to cast the result of malloc(), nor is it recommended.