Is this correct for assigning/dereferencing double ptr in struct?

[Syscal]

Say I have the following:

struct node{
    node **somenode;
    node *othernode
}foo;

void somefunc(struct node *foo){

}

How would I dereference somenode? Also, how could I point it to othernode?

My compiler kept yielding warnings with some things I tried and so I've come to find that this works. But is it the correct way? Out putting addresses showed that somenode referenced what foo->othernode referenced instead of referencing foo->othernode itself.

void somefunc(struct node *foo){

     foo->somenode = &*(foo->othernode);
}

Simply doing:

void somefunc(struct node *foo){

     foo->somenode = &foo->othernode;
}

gives me warnings.

[laserlight]

It looks like that should be:

struct node{
    struct node **somenode;
    struct node *othernode;
};

void somefunc(struct node *foo) {
    *foo->somenode = foo->othernode;
}

Assuming that foo->somenode already points to a struct node pointer. Why do you want the somenode member, anyway?

[Syscal]

No particular reason, I just was curious as to how it worked. I thought I needed it at one point but turned out I didn't. It was a stack implementation and I was going to use a double pointer member as the stack pointer. Like I said, I didn't need it so I decided not to use it.

[Bayint Naung]

Simply doing:

void somefunc(struct node *foo){

     foo->somenode = &foo->othernode;
}

What warning? Why not post it?
Btw,

struct node{
    node **somenode;
    node *othernode
}foo;

Here foo is a global variable of type struct node. I'm not sure you really mean it?
Edit: If you are using C, I guess you have typedef struct node node; before your struct node definition?

[Syscal]

Edit: nevermind that code...

This should give you an idea of what I'm talking about;


the structures(not global):

struct stack_node_t{
    struct stack_node_t *next;
    void *data;
};

struct stack_t{
    struct stack_node_t **stack_ptr;
    struct stack_node_t *root;
    int size;
    int max;
};

void push(struct stack_t *stack, void *data){
    if(stack->size < stack->max){
        if(!stack->size){
            stack->root = malloc(sizeof(struct stack_node_t));
            stack->root->next = NULL;
            stack->root->data = data;
        }
        else{
            (*stack->stack_ptr)->next = malloc(sizeof(struct stack_node_t));
            stack->stack_ptr = &(*stack->stack_ptr)->next;
            (*stack->stack_ptr)->next = NULL;
            (*stack->stack_ptr)->data = data;
        }
        stack->size++;
    }
    else{
        fputs("ERROR: Stack overflow\n", stdout);
    }
}

[Bayint Naung]

Complicated for a stack!!!
What's the point of struct stack_node_t **stack_ptr; ??

[Syscal]

haha, I know, thats why I opted not to use it. I just would like to know for future reference how these double pointer members ought be dereferenced. The idea was that it points to the top of the stack. I realize I dont need it though.