Does passing "pointer to structure" to a function create local copies of it in C?

Question

I have a structure like this

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

Which I use to create singly linked list.

I created other functions like

int push(struct node* head,int element);

which pushes data onto stack created using node structs.

The function then tries to update the struct node* head passed to it using code(it does other things as well)

head=(struct node*)malloc(sizeof(struct node));

The call is made as such

struct node* stack;
push(stack,number);

It looks like this code created copy of the pointer passed to it. So I had to change the function to

int push(struct node** head,int element)

and

*head=(struct node*)malloc(sizeof(struct node));

The call is made as such

struct node* stack;
push(&stack,number);

So my question is, what was the earlier function doing? Is it necessary to pass struct node** to the function if I want to update original value of pointer or is my approach wrong?

Sorry I cannot provide complete code as it is an assignment.

Answer 1

C always passes by value. To change a variable passed to a function, instead of passing the variable itself, you pass a reference(its address).

Let's say you're calling your function with the old signature

int push(struct node* head,int element);

struct node *actual_head = NULL;
push(actual_head, 3);

Now before calling push, your variable actual_head will have value as NULL.

Inside the push function, a new variable head will be pushed to stack. It will have the same value as passed to it, i.e. NULL.

Then when you call head = malloc(...), your variable head will get a new value instead of actual_head which you wanted to.

To mitigate the above, you'll have to change the signature of your function to

int push(struct node** head,int element);

struct node *actual_head = NULL
push(&actual_head, 3);

Now if you notice carefully, the value of actual_head is NULL, but this pointer is also stored somewhere, that somewhere is its address &actual_head. Let's take this address as 1234.

Now inside the push function, your variable head which can hold the address of a pointer(Notice the two *), will have the value of 1234

Now when you do *head = malloc(...), you're actually changing the value of the object present at location 1234, which is your actual_head object.

Answer 2

C always passes parameters by value (i.e., by copying it). This applies even to pointers, but in that case, it is the pointer itself that is copied. Most of the times you use pointers, that is fine, because you are interested in manipulating the data that is pointed to by the pointer. However, in your situation, you want to modify the pointer itself, so you do indeed have to use a pointer to a pointer.

Answer 3

Yes.

The first version of your program was passing the pointer by value. Although it passed an address (held by the pointer to struct) it didn't pass the pointer's address - necessary to update the value.

Whenever you want to update a variable's value you must pass the variable's address. To pass a pointer address, you need a parameter pointer to pointer to type.

In your case, pointer to pointer to struct node.