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

我有一个具有此结构的节点：

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

调用。但是每当我创建一个节点时，我总是创建两个虚拟节点。 所以我想做一个malloc，为

lChild

和

rChild

分配内存。 可能分配一个双字并引用其部分。但我不知道怎么做

我试过这种方法。但我还是需要做两个马洛克

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

---

如果要为两个节点分配单个内存块，请尝试

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

---

然后，

&ptrtotownodes[0]

和

&ptrtownodes[1]

将成为指向这两个节点的指针。顺便说一下，我想你应该删除C++标签。

如果你想为两个节点分配一个内存块，请尝试< /P>

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

---

然后，

&ptrtotownodes[0]

和

&ptrtownodes[1]

将成为指向这两个节点的指针。顺便说一下，你应该删除C++标签。< /p> 你可以为2个节点分配内存，并将指针分配给变量：

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

---

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

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

---

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

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

---

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

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

---

修改代码如下所示：

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

注意如何

释放（）

还要将错误检查添加到所有这些
malloc（）
s

另外^2:
修改如下代码：

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

注意如何
释放（）

还要将错误检查添加到所有这些
malloc（）
s

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

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

问题的根源在于，您无法
释放（）返回my
malloc（）
的内存段的一部分。对于由
malloc（）
返回的每个指针，您始终必须准确地调用
free（）
——不多也不少

如果malloc对您来说太昂贵，那么另一种方法是创建一组帮助函数，以保持一个节点结构池（因此它们一次分配N，然后一个接一个地返回，直到池用完）。请参阅。
虽然从技术上讲，您可以使用单个
malloc（）
分配所有三个节点，但您确实不应该这样做，因为它破坏了树结构的递归“对称性”

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

问题的根源在于，您无法
释放（）返回my
malloc（）
的内存段的一部分。对于由
malloc（）
返回的每个指针，您始终必须准确地调用
free（）
——不多也不少

如果malloc对您来说太昂贵，那么另一种方法是创建一组帮助函数，以保持一个节点结构池（因此它们一次分配N，然后一个接一个地返回，直到池用完）。请参阅。
struct node*ptrToTwoNodes=（struct node*）malloc（2*sizeof（struct node）），<代码>（pTrtoToNoDes）<代码>，代码>（pTrtoTouOndo+ 1）要考虑的一个重要事项是，如果在单个<代码> MalCube（）/代码>调用中分配多个节点，则需要将这些节点作为块来释放。这可能意味着您必须跟踪要释放的指针，并且只有当指向它的所有指针不再使用时才释放该块。如果您需要能够独立地释放
lChild
或
rChild
（或以其他方式将所有权转移到可能包含指向
节点的指针的其他对象上
），则应坚持使用单独的
malloc（）
调用。相关：。
struct node*ptrToTwoNodes=（struct node*）malloc（2*sizeof（struct node）），<代码>（pTrtoToNoDes）<代码>，代码>（pTrtoTouOndo+ 1）要考虑的一个重要事项是，如果在单个<代码> MalCube（）/代码>调用中分配多个节点，则需要将这些节点作为块来释放。这可能意味着您必须跟踪要释放的指针，并且只有当指向它的所有指针不再使用时才释放该块。如果您需要能够独立地释放
lChild
或
rChild
（或者将所有权转移到可能包含指向
节点的指针的其他对象上
），则应坚持使用单独的
malloc（）
调用。相关：。很好的解释！！谢谢我尝试做单一malloc的三个原因。1.我没有做任何GC。2.我在并发环境中使用它，但还没有找到GC算法。3.这些特殊节点永远不会更改值，它们只会被另一个内部节点替换。3：如果“替换”表示“更改l/rChild指针”，请记住，这将造成（小）内存泄漏。我现在的感觉是，你有一个解决问题的想法，但这个想法不好。也许如果你告诉我们你想解决什么问题，我们可以给你提供更好的选择。当我“替换”一个节点时（是的，我正在更改l/r子指针），我仍然无法释放这个被替换节点的内存。原因是