链表的堆栈实现中的双指针

Question

I was reading a book recently and this is the explanation for implementing stack in Linked list. Here follows the explanation:

typedef struct Element { 
    struct Element *next; 
    void *data;
} Element;

The corresponding prototypes for push and pop follow:

void push( Element *stack, void *data );
void *pop( Element *stack );

Now consider what happens in these routines in terms of proper functionality and error handling. Both operations change the first element of the list. The calling routine's stack pointer must be modified to reflect this change, but any change you make to the pointer that is passed to these functions won't be propagated back to the calling routine. You can solve this problem by having both routines take a pointer to a pointer to the stack. This way, you can change the calling routine's pointer so that it continues to point at the first element of the list. Implementing this change results in the following:

void push( Element **stack, void *data );
void *pop( Element **stack );

However, what I wonder is, what is the need to put double pointers for the stack? I understand the concept of double pointers, but however, when a new node is created using Element *node1 = (Element *) malloc (sizeof(Element)); , we already have the pointer to the node. Why not just send this pointer itself instead of using double pointer?

Answer 1

Because you don't have a standalone Stack object, every time you change the top node in the stack, the primary reference to that stack needs to change for everything using it. This is why the double pointer is needed -- because the old top of the stack isn't valid anymore.

If you created a top-level stack object, which has a pointer to an Element and maybe some other data like a element count, then you would be able to send that in to push/pop as a single pointer because that object/struct would remain the same, only the data inside it would change.

// pseudocode
struct Stack {
  Element * top = NULL;
  int size = 0;
}

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

function push(Stack * stack, void * data) {
  Element * element = new Element(data);
  element->next = stack->top;
  stack->top = element;
  size++;
}

// pop left as an exercise to the reader.. :)

int main(void*) {
    Stack * stack = new Stack;
    push(stack, "foo"); <== no need for double pointer
    pop(stack); 
    printf("%d\n", stack->size);
}

Answer 2

This is a bit confusing due to a common mix-up of concepts of pointers and passing by reference .

Let's take look at the original push function. The stack parameter represents a pointer to the beginning of the stack. This pointer is provided by the caller. If the beginning of the stack needs to be modified, the push function won't be able to do this because it was passed by value , ie, inside function body it's a copy of the original. Same goes for pop .

It's easiest to understand with an example. Let's say the beginning of the stack resides at address 0x1234 . When push is being called, the value 0x1234 is passed to it by the caller. push can do whatever it desires with this value, but it won't change the data of the original pointer and the changes won't be reflected at the caller context.

Why not send the node1 pointer that you've created inside push : Element *node1 = (Element *) malloc (sizeof(Element)); ? That's exactly what you should do but you still need double pointer:

void push( Element **stack, void *data )
{
    Element *node1 = (Element *) malloc (sizeof(Element));
    node1->data = data;
    node1->next = *stack;
    *stack = node1;
}

If you attempt to achieve this without double pointer, the caller won't see the changes and will remain with an old stack pointer:

void push( Element *stack, void *data )
{
    Element *node1 = (Element *) malloc (sizeof(Element));
    node1->data = data;
    node1->next = stack;
    stack = node1;         //The data structure was updated but caller won't see it!
}