C 堆栈实现。 关于解引用和双指针的问题

Question

Good day everyone. I am new to C and stack overflow too so go easy on me please:) I have few question about this stack code in C:

1) push(&stackPtr, value); why stackPtr has to have & sign? and what function will get without it?

2) topPtr = newPtr; why topPtr has to be *topPtr? And what is going on with the code without it?

3) *topPtr = (*topPtr)->nextPtr; why *topPtr has to have *? and what gonna be without * sign?

Thank for any answers in advance.

#include <stdio.h>
#include <stdlib.h>

// self-referential structure                     
struct stackNode {                                   
   int data; // define data as an int             
   struct stackNode *nextPtr; // stackNode pointer
};

typedef struct stackNode StackNode; // synonym for struct stackNode
typedef StackNode *StackNodePtr; // synonym for StackNode*

// prototypes
void push(StackNodePtr *topPtr, int info);
int pop(StackNodePtr *topPtr);
void printStack(StackNodePtr currentPtr);
void instructions(void);

// function main begins program execution
int main(void)
{ 
   StackNodePtr stackPtr = NULL; // points to stack top
   int value; // int input by user

   instructions(); // display the menu
   printf("%s", "? ");
   unsigned int choice; // user's menu choice
   scanf("%u", &choice);

   // while user does not enter 3
   while (choice != 3) {

      switch (choice) { 
         // push value onto stack
         case 1:      
            printf("%s", "Enter an integer: ");
            scanf("%d", &value);
            push(&stackPtr, value);
            printStack(stackPtr);
            break;
         // pop value off stack
         case 2:      
            // if stack is not empty
            if (stackPtr != NULL) {
               printf("The popped value is %d.\n", pop(&stackPtr));
            }

            printStack(stackPtr);
            break;
         default:
            puts("Invalid choice.\n");
            instructions();
            break;
      } // end switch

      printf("%s", "? ");
      scanf("%u", &choice);
   }

   puts("End of run.");
}

// display program instructions to user
void instructions(void)
{ 
   puts("Enter choice:\n"
      "1 to push a value on the stack\n"
      "2 to pop a value off the stack\n"
      "3 to end program");
}

// insert a node at the stack top
void push(StackNodePtr *topPtr, int info)
{ 
   StackNodePtr newPtr = malloc(sizeof(StackNode));

   // insert the node at stack top
   if (newPtr != NULL) {           
      newPtr->data = info;
      newPtr->nextPtr = *topPtr;
      topPtr = newPtr; 
   }                     
   else { // no space available
      printf("%d not inserted. No memory available.\n", info);
   } 
}

// remove a node from the stack top
int pop(StackNodePtr *topPtr)
{ 
   StackNodePtr tempPtr = *topPtr;             
   int popValue = (*topPtr)->data;  
   *topPtr = (*topPtr)->nextPtr;
   free(tempPtr);               
   return popValue;
}

// print the stack
void printStack(StackNodePtr currentPtr)
{ 
   // if stack is empty
   if (currentPtr == NULL) {
      puts("The stack is empty.\n");
   } 
   else { 
      puts("The stack is:");

      // while not the end of the stack
      while (currentPtr != NULL) { 
         printf("%d --> ", currentPtr->data);
         currentPtr = currentPtr->nextPtr;
      }

      puts("NULL\n");
   } 
}

Answer 1

This is all pretty basic C, so I'll try to be as clear as possible, but I suggest you to carefully read reference books on the topic.

This code defines a structure stackNode which contains some data, and a "pointer" to this same structure.

Because stackNode is a structure, when you pass it as a parameter to a function, the compiler creates a copy of it and gives it to the function. This is called "passing parameter by copy". Example:

StackNode node;
foo(node) ;

void foo(StackNode  n) {
   /* foo() function can use the parameter n which is a local copy of node.
      you can modify n in the foo() function, that will not modify the node variable */
}

This implies that the function can not modify your original data. It can modify the function's local copy, which is lost at the end of the function.

If you want to modify the given parameter, you must pass the parameter "by address" rather than "by copy". You do it this way:

StackNode node;
foo(&node) ;

void foo(StackNode  *n) {
   /* foo() function accesses the node variable via its address n. (*n) represents
      the content at address n, which is node. */
}

In this code, the function foo() gets the address of a StackNode (and not a copy of a StackNode). By "de-referencing" the address, you can access the content that is "pointed to" by the pointer, and therefore modify it "for real". "De-referencing" is performed by the "*" operator, while the "&" operator gives the "reference" (the address) of a variable.

So now, to your code. I'll answer your questions in a slightly different order, to make it clearer (I think).

What void push(StackNodePtr *topPtr, int info) does is to malloc a new node, make it point to the current topPtr, and then modifies topPtr to point to this new node.

Therefore it modifies topPtr.

Therefore topPtr needs to be passed by reference.

Therefore you need void push(StackNodePtr *topPtr, int info) and not void push(StackNodePtr topPtr, int info)

Therefore you need to call it with push(&stackPtr,value)

If you call push(stackPtr,value) , then:

• First of all, your compiler should complain (at least raise a warning)
• You will crash one day or another as you will be modifying unknown zones of memory

You should also now understand why you need (*topPtr) = newPtr instead of topPtr = newPtr . Because you want to modify stackPtr, and you need to de-reference topPtr.

Same in the latter code.

This said, I can think of much easier to implement a stack... ;-)