C - Creating node with multiple children by function - segmentation fault - c

Question

I want to create tree with multiple children and create every node with a function. Here is my structure for node:
typedef struct node {
char *string; // Name of the node
int number_of_children;
struct node *children[];
} node;
And here is my function to create new node (with four children):
node *add_node(char *string, node *left, node *middle_left, node *middle_right, node *right) {
node *p;
if ((p = malloc(sizeof(node))) == NULL) yyerror("Memory error");
p->string = strdup(string);
p->children[p->number_of_children] = left;
p->children[p->number_of_children + 1] = middle_left;
p->children[p->number_of_children + 2] = middle_right;
p->children[p->number_of_children + 3] = right;
p->number_of_children = 4;
return p;
}
When I run this function value under p->string is changed to some garbage. When I wanted to set fixed number of children (in the structure I changed struct node *children[] to struct node *children[4]) I get segmentation fault. Do you have any ideas?

Answer 1

The way you define your struct, you must know how many children you can have beforehand, because you have to allocate the memory for the last member explicitly:
node *p = malloc(sizeof(node) + nchildren * sizeof(node));
You could reallocate to accomodate more nodes later, but this isn't a feasible approach here, because the handle to the reallocated memory might change, which will break the tree connectivity.
There are better approaches to have nodes with a varying number of children, for example:
Settle on a fixed maximum number of children, maybe 4, and make the member array children explicitly 4 elements long. Keep a number that tells you how many children are valid.
Make the list of children a dynamically allocated array that you can reallocate later. This means you have a two-level allocation: First thze node proper, then a list of its children.
Keep a linked list of child nodes. Come to think of it, you could rearrange the tree so that each node has a child for its oldest child node and a sibling node fo the next oldest sibling of each node.
I'm not sure what you want to do exactly, but the first approach seems to be the simplest for your concerns.
Your code has several other errors:
You should only allocate memory when you create a node. Obviously, you already pass in valid node handles to your function. These nodes have already memory allocated to them or they are NULL. The following:
p = malloc(sizeof(*p));
p = pref;
will allocate memory and immediately lose the only handle to that memory, which is a memory leak. You don't need to allocate here, just say p = pref.
The memory allocated with malloc isn't initialised; it contains garbage. Initialise all struct members before you use them. Alternatively, consider using calloc, which allocates and zeroes out the memory.
Combined assignments and checks as in if ((p = malloc(sizeof(node))) == NULL) are valid, but complicated to read. In my opinion, they are better separated into assignment and subsequent check. (After all, it just saves you typing p twice at the cost of some extra parantheses.)
An example where you pass in a variable number of chilödren by array might look like this:
typedef struct node {
char *string;
size_t number_of_children;
struct node *children[4];
} node;
node *add_node(char *string, node *child[], size_t n)
{
node *p = malloc(sizeof(*p));
size_t i;
if (p == NULL) yyerror("Memory error");
p->string = strdup(string);
for (i = 0; i < n; i++) p->children[i] = child[i];
p->number_of_children = n;
return p;
}