链接列表和双指针

Question

In the below code, I am trying to insert a node after a particular node. In the function, I will be giving as input the address of the previous node after which I want to insert the new node. The problem is in the 10th line of function insertAfter() - it says I cannot access *prev_ref->next.

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

 struct node
 {
  int data;
  struct node* next;
 };

 void push(struct node **head_ref, int data)
{

struct node* newNode = (struct node*)malloc(sizeof(struct node)) ;
newNode->next= *head_ref;
newNode->data= data;
*head_ref= newNode;

}


void insertAfter(struct node **prev_ref, int data)
{
if(*prev_ref==NULL)
{
    printf("prev ref cant be null");
    return;
}
struct node * newNode;
newNode = (struct node*)malloc(sizeof(struct node)) ;
newNode->next= *prev_ref->next;
newNode->data= data;
*prev_ref->next= newNode;

}


 void printList(struct node *node)
    {
     while (node != NULL)
      {
       printf(" %d ", node->data);
       node = node->next;
    }
   }

main()
{
struct node* head = NULL;
push(&head, 7);
push(&head, 1);
insertAfter(&head, 8);
printf("\n Created Linked list is: ");
printList(head);
 getchar();
 return 0;

 }

Answer 1

Do you know (*p).s is equivalent to p->s ? I would suggest you to try something like (*prev_ref)->next or (**prev_ref).next

Answer 2

You seem to dereference prev_ref three-levels deep instead of two.

pointer->field is dereference of a pointer, equivalent to (*pointer).field

So, **prev_ref->next; is in fact (***prev_ref).next;

Either drop one asterisk or use . instead of -> .

EDIT: You seem to have skipped the parentheses we included in our answers.

-> has higher precedence than * .

The effect is:

(*prev_ref)->next

• first uses '*' and finds the memory pointed to by prev_ref (let's call it memory location A ),
• then uses '->' to find memory pointed to by A , let's call it B ,
• then location of the the next field of the structure, offset by a set distance from B , let's call it C
• and finally accesses (reads/writes) the value stored at C.

Now for *prev_ref->next

• first, uses -> and finds the memory pointed to by prev_ref (A), just the same
• then the location of the the next field of the structure, offset by a set distance from A , which happens to be an entirely random location in memory (because A stored a pointer to the structure, not the structure itself); let's call that location D.
• Then it tries to find the memory location at wherever D pointed to, which is entirely random.

Now, the system won't let you do that, because it sees A is not where a structure lies, but where a pointer to a structure lies, hence the error message

And the fundamental reason of your problems is that you use pointers-to-pointers for no good reason. Nothing of this would have happened if you always used plain pointers. void push(struct node *head_ref, int data) , void insertAfter(struct node *prev_ref, int data) , prev_ref->next etc. Managing pointers to pointers is tricky, error-prone (as you've experienced) and in 99% cases completely unnecessary.