通过值和引用将c中的结构类型指针传递给函数

Question

okay, I know for a fact that passing pointer to a structure as argument to a function makes the argument behave as though it was passed by value, just for the special case of structures. So if I were to make any modifications to head ptr in the link list, the changes made in the called function wouldn't be reflected in the calling fnt., but my question is whether changes made to any subsequent node's pointer in the called function is reflected in the calling function..for example , if I were to say delete the fifth node from the beginning of a link list whose head pointer i passed by using single pointer instead of double pointer,would the list returned from the function contain the deleted element or would it not contain it?

ok another example: in the following code to recursively delete alternate elements in a link list, wouldnt it fail, because the parameter is *head instead of **head?

void deleteAlt(struct node *head)
{
  if (head == NULL)
    return;

  struct node *node = head->next;

  if (node == NULL)
    return;

  /* Change the next link of head */
  head->next = node->next;   

  /* free memory allocated for node */
  free(node);

  /* Recursively call for the new next of head */
  deleteAlt(head->next);
}

Answer 1

I know for a fact that passing pointer to a structure as argument to a function makes the argument behave as though it was passed by value, just for the special case of structures.

That's simply not true. The pointer itself if passed by value (as every argument is in C), but the variable referenced by the pointer isn't copied. Changing it in the function will change it in the caller since it's the same structure.

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

struct S {
   int i;
};

void f(struct S* s) {
   s->i = 456;
}

int main() {
   struct S* s = malloc(sizeof(struct S));
   s->i = 123;
   printf("%d\n", s->i);
   f(s);
   printf("%d\n", s->i);
   free(s);
   return 0;
}

$ gcc -o a a.c && a
123
456

---

ok another example: in the following code to recursively delete alternate elements in a link list, wouldnt it fail, because the parameter is *head instead of **head ?

No. Since deleteAlt never modifies head , there's no need to update its caller's head , so there's no need to pass a pointer to the caller's head .

Answer 2

Pointers to structures passed by value behaving as entire structures being passed by value is obviously not true.

By the way, C doesn't have "pass by reference". You can pass the pointer to something, but then that happens by value.

Answer 3

If you passed a pointer to the link list and modified it (deleted an element) the value you removed would be removed in the context of the caller.

The very simplest reason they would need (struct node ** head) is because to modify something you need its address. If you are going to delete something (*head in this case) you are going to need its address. Anything that you want to modify you need its address.

Answer 4

To delete a node, you have to redirect the next pointer of the previous node to point to the next node instead of the current one. Since we don't have a pointer to the previous node, we can't redirect its next pointer. So what do we do?

We can easily get away by moving the data from the next node into the current node and then deleting the next node.

This solution has O(1) runtime. Here's some code to illustrate this simple logic.

void deleteNode( Node * node )
{
    Node * temp = node->next;
    node->data = node->next->data;
    node->next = temp->next;
   free(temp);
}

Some things to consider.

This method could pose potential problems.

For instance, let's consider we have a linked list A -> B -> C -> D and we are given a pointer to B to delete it.

Theoretically, you would expect B to be deleted and all pointers which were pointing to   B to become invalid.

However, if we use this function to delete B, all pointers which were pointing to B will still be valid. Furthermore, node B now will contain the value C and node C will be invalid.

Any previous pointers to C will become invalid, which may not be expected behavior in general. This is not a problem if there are no external links to any of the items in the linked list.

But this would definitely be something you should consider asking your interviewer to show your thinking process.

For proper understanding working of deleting an element from the linklist please refer following link :

https://www.cs.bu.edu/teaching/c/linked-list/delete/

Pointers are address variables ie they contains addresses, so if a pointer is passed to a function , you are passing the actual value itself.

On performing any action on it , that value will be modified. In your case it will be deleted.