what is the meaning of a double pointer of struct in C - c

Question

I have a problem understanding this structure , would love to get a clear explanation.
typedef struct exp{
int x;
struct exp *parent;
struct exp **children;
}
what does it mean the parent and the children ?
"parent" is an array of this structure?
and what is the meaning of the children ? it's an array of arrays?!
I really can't understand..
and last thing, If I'm adding an element , it becomes a specific child of some parent, how can I reach all the children of a parent? shouldn't it be a structure "List" (using next etc .. ? )?
thank you!!

Answer 1

This image shows a possible scenario:
It was obtained using this code and DDD
#include <stdio.h>
#include <stdlib.h>
struct exp{
int x;
struct exp *parent;
struct exp **children;
};
int main ()
{
struct exp *x = calloc(1, sizeof(x[0]));
x->x = 42;
x->parent = calloc(1, sizeof(x[0]));
x->children = calloc(5, sizeof(x->children[0]));
x->children[0] = calloc(1, sizeof(x[0]));
x->children[2] = calloc(1, sizeof(x[0]));
x->children[3] = calloc(1, sizeof(x[0]));
x->children[4] = calloc(1, sizeof(x[0]));
return 0;
}
Basically, the children field is a vector of pointers to struct exp. You decide how many elements to put there and the other things.
PS: Code is only a demo, it has not quite a good quality.

Answer 2

It's a pointer to a pointer, which in that case seems to be used as a list of struct exp.
Each struct exp has a reference to it's "parent", and a pointer to a list of children struct exp.
typedef struct exp{
int x;
struct exp *parent;
struct exp **children;
} element;
// create ROOT elemnt
element * root = (element*) malloc(sizeof(element)); //alocate mem. for 1 element
Once we have a "root" we can add children, following is pseudo-code
for 1 to 10{
child = new element;
child->parent = root; // tell the child who is his parent
addToRoot( root , child); // call a function that inserts elemnts to root
}
So now we should have root with a list of 10 elements:
_______________ _______________
| | (children) | | - (parent) points to struct exp, root
| root | - points to list of struct exp -> | child 0 |
| | | | - (children) points to null; // if it's empty
_______________ _______________
_______________
| | - (parent) points to struct exp, root
| child 1 |
| | - (children) points to null; // if it's empty
_______________
_______________
| | - (parent) points to struct exp, root
| child 2 |
| | - (children) points to null; // if it's empty
_______________
_______________
| | - (parent) points to struct exp, root
| child 3 |
| | - (children) points to null; // if it's empty
_______________
.
.
.
_______________
| | - (parent) points to struct exp, root
| child 9 |
| | - (children) points to null; // if it's empty
_______________
Something like that... Did it help?

Answer 3

It's an array of pointers to child nodes- this looks like some kind of tree structure.
There is a parent node for each node, and each node has one or more children. You can travel from a parent to one of its children with
expInstance->children[i];
Where i is a number indicating one of the child nodes. It's not really clear how many child nodes there are from this definition- it could be one, or two, or a million. But given that information you could loop through them. Either with
for(i=0; i<NUMBER_OF_CHILDREN_NODES;i++){
expInstance->children[i];
}
if you know the length of the array in advance or the somewhat strange
while(expInstance.children[i++]){
expInstance->children[i];
}
(There are a couple variously clever ways to do this, but there has to be the assumption built into the structure that there will be a null pointer in the last slot of this array in order to terminate it.)

Answer 4

It is hard to say without seeing more code. Are you trying to implement a tree? From this definition, this is what apparent to me:
parent points to the parent node of this structure.
children points to the array of pointers of all its child nodes.

Answer 5

First of all, remember that a structure cannot contain an instance of itself. IOW, you cannot do something like
struct exp {
int x;
struct exp parent;
...
};
The main reason for this is that the struct type is not complete at the point where you try to declare the parent member; since you haven't finished describing the type yet, the compiler doesn't know how big the parent member should be. Not to mention that the parent member would itself have a parent member of type struct exp, which would in turn have a parent member of type struct exp, which would in turn have a parent member of type struct exp, etc., etc., etc., etc. You'd wind up with an object that required an infinite amount of storage.
So you cannot have a member of type struct exp. However, you can have a pointer to an object of type struct exp; you can create pointers to incomplete types, and all struct pointer types have the same size and representation (IOW, struct foo *pf and struct bar *pb will have the same size, even if struct foo and struct bar do not).
So the parent member is (probably) only meant to point to a single instance of type struct exp (each instance of struct exp has one parent). Likewise the children member is (probably) meant to be a single-dimensioned array of pointers to struct exp (each instance of atruct exp can have zero, one, or more children).