指向结构的指针成员以在C中构造自己

Question

Here are two structs I'm using. I'm not sure how to initialize so that member of the struct points to struct itself. I'm not sure if this is possible or not.

typedef struct __node 
{
   int value;
   struct __node* left;
   struct __node* right;
}setNode;

typedef struct __set {
   setNode* root;
   //mutex for this set (To be implemented)
}set;

I want to initialize members of set but not sure how should I do to get result->root to point to same address as that of set result .

set* new_set() 
{ 
  set* result = malloc(sizeof(set));
  result -> root = NULL; // Not sure???
}

I want to get the pointer to root.

void someOther(set* s)
{
   setNode* temp = s -> root;
   //....
}

Sorry if the question is too vague.

Additional Info

I want two structs. One which is contains nodes of a tree[setNode] and second struct which contains pointer to root of the tree and some other members(like mutex for that tree)[set]. That is not a problem.

Problem: In a function, I have setNode* temp = someSet -> root; such that I should be able to traverse over the tree ie temp should point to root of someSet. So what should I assign to result -> root in new_set function?

Answer 1

An empty set doesn't contain any elements. If a set is represented by a binary search tree, a NULL root pointer is appropriate for that.

set* new_set() 
{ 
   set* result = malloc(sizeof(set));
   result -> root = NULL; // Yes, absolutely positively 100% sure
   return s; // Don't forget!
}

If you want to get the pointer to root, get it.

void someOther(set* s)
{
    setNode* temp = s -> root;
    //!!!!
}

Nothing whatsoever is wrong with temp being NULL. Your function must be able to handle that. If you want a recursive traversal function, write one that gets a setNode* argument:

void someOther(set* s)
{
    setNode* temp = s -> root;
    someOtherDoThisActuallyIMeanItNow (temp);
}

void someOtherDoThisActuallyIMeanItNow (setNode* current)
{
    ...
    if (current) { // <-- here we check that it's not NULL
       ...
       someOtherDoThisActuallyIMeanItNow (current->left);
       ...
       someOtherDoThisActuallyIMeanItNow (current->right);
    } else {
       // do whatever is appropriate for an empty tree/set
    }
}

If you need a function that recursively traverses and modifies a tree, make one that accepts a setNode** argument.

void someOtherWithMutation(set* s)
{
    setNode* temp = s -> root;
    someOtherWithMutationNow (&temp); // <---- here
}

void someOtherWithMutationNow (setNode** current) // <---- here
{
    ...
    if (*current) { // <-- here we check that it's not NULL
       ...
       someOtherDoThisActuallyIMeanItNow ((*current)->left);
       ...
       someOtherDoThisActuallyIMeanItNow ((*current)->right);
       ...
       if (...) {
           free (*current);
           *current = NULL;
       }           
    } else {
       // do whatever is appropriate for an empty tree/set
       ...
       *current = malloc(sizeof(setNode));
       ...          
    }
}