具有双指针的Malloc结构

Question

I have a structure that looks like this:

typedef struct{
    char* name;
    int count;
    Node **subnodes;
}Node;

I receive name and count over network one by one for the whole k-ary tree and then I reconstruct the tree. How do I malloc this struct?

Node *n = NULL;
fun(n, buf); //call function fun

void fun(Node *n, void *buf){
    //successfully extracted name and count from buf
    // say count is 5, i.e. this node should have 5 subnodes and 
    // name is root
    n = malloc(sizeof(*n)+strlen(name));
    n->name = name;
    n->count = count;
    for(int i=0; i<n->count;i++)
         fun(n->subnodes[i], buf+some_increment);
}

This crashes as soon as I call fun for the second time. How should I malloc properly? Should I be malloc-ing each subnode?

Answer 1

First off, you realise this is leaky? n is just on the stack - you aren't returning it or "saving" the value you give it anywhere permanently.

Then you haven't actually allocated any memory for subnodes , so by indexing into it you are reading unallocated memory.

Without a more complete example it is hard to further, but at a minimum you need to malloc something for subnodes .

Answer 2

Yes, you will have to malloc each node. I see a couple of issues here:

1. You are neglecting in malloc(sizeof(*n)+strlen(name)) to provide space for the null terminator. This statement should read malloc(sizeof(*n)+strlen(name)+1) . Also you should set the name pointer in the struct to the end of the struct and then strcpy the buffered name to it

   n -> name = (char *)(n + 1) strcpy(n -> name, buffered_name)

   I presume the buffered version is transient.

2. You are allocating no space for the variable sized array of child nodes. This has to be done as a separate malloc or you have to embed it in the Node malloc (I'd recommend placing it between the Node header and the name string content.

Note, I am making a few liberal assumptions about what the code really looks like since this is clearly an incomplete snippit with typos. eg subnodes <-> subnode

Addendum: Code snippet (untested so normal caveats apply):

typedef struct
{
    char* name;
    int count;
    Node **subnodes;
}
  Node;

Node *fun(void *buf)
{
    ...
    //successfully extracted name and count from buf
    // say count is 5, i.e. this node should have 5 subnodes and 
    // name is root

    // Allocate space for the node and its data.
    Node *node_ptr = malloc(sizeof(Node) + count * sizeof(Node *) + strlen(name) + 1);

    // Set the name pointer and copy the name from the I/O buffer.
    node_ptr -> name = (char *)(node_ptr + 1) +  count * sizeof(Node *); // set the name pointer to the right location.
    strcpy(node_ptr -> name, name); // copy the buffered value to the node value.

    // Establish the count from the I/O buffer.
    node_ptr -> count = count;

    // Set the subnodes address.
    node_ptr -> subnodes = (char *)(node_ptr + 1);

    // Get the child nodes.
    for(int child = 0; child < node_ptr -> count; child++)
        node_ptr -> subnodes[child] = fun(buf + some_increment);
}

Answer 3

I have a structure that looks like this:

  typdef struct{
        char* name;
        int count;
        Node **subnodes;
    }Node;

Not really, because it is typedef not typdef .

As John3136 pointed out, your function allocates memory in n which is a local variable. Plus you are assigning count and name which do not appear to be passed to fun .

It also looks to me like the function fun will recurse indefinitely.

You call fun which (in the last line) calls fun which therefore calls fun again, and so on until you run out of stack.

---

(Edited to add)

Trying to guess what is wanted, I have got this working example going:

#include <memory.h>
#include <stdlib.h>
#include <stdio.h>

typedef struct Node {
    char* name;
    int count;
    Node **subnodes;
}Node;

void makeNode(Node * &n, const char * name, const int count)
  {
  // make the node itself
  n = (Node *) malloc(sizeof(*n));
  // allocate room for the name
  n->name = (char *) malloc (strlen (name) + 1);
  // copy in the name
  strcpy (n->name, name);
  // save the count of subnodes
  n->count = count;
  // allocate memory for subnode pointers (not the subnodes themselves)
  if (count > 0)
    n->subnodes = (Node **) malloc (sizeof (Node *) * count);
  else
    n->subnodes = NULL;
}  // end of makeNode

int main ()
  {
  Node *node = NULL;
  makeNode(node, "foo", 3);
  makeNode(node->subnodes [0], "the", 0);
  makeNode(node->subnodes [1], "slithy", 0);
  makeNode(node->subnodes [2], "toves", 0);

  for (int i = 0; i < 3; i++)
    printf ("Node %i, name = %s\n", i, node->subnodes [i]->name);
  printf ("Done!\n");
  } // end of main

This runs OK:

Node 0, name = the
Node 1, name = slithy
Node 2, name = toves
Done!

Note, I compiled with g++, not gcc. However it should give you some ideas to go on with.

(You don't have references in C, so you really need C++ for this to work)