当按值传递指针时，内部会发生什么？

Question

Suppose I have a following linked list structure:

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

And the following function to print the linked list:

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

Now in the main() function when I write this:

print(head); // Assume head is the pointer pointing to the head of the list

This is essentially call-by-value. Because ptr in print will receive a copy of head . And we can't modify head from the print() function because its call-by-value.

But my doubt is, since ptr receives a copy of head but it's able to print the value of linked list. So does that means the print() function receives whole copy of linked list? If it does not receives the whole copy of linked list how its able to print the list?

Answer 1

Your function receives a copy of the pointer. The copy of the pointer points to the same place as the original pointer.

A pointer is like an address. Here's an analogy. Imagine writing your address down on a piece of paper. When you want to give it to a friend you copy the address: that is, you write the same address on a new piece of paper and give that paper to your friend. But if they go to the address written on their copy, they'll go to the exactly same place as if they had gone to the address on the original piece of paper.

Answer 2

print receives a copy of the address of head, which means that the data representing head isn't copied: the function is using the actual head and hence the actual linked list, not a copy.

The implications are that you can change head , eg head->data , and you can modify the rest of the linked list. The only thing that you can't do is change which node your passed-in pointer points to, ie you can't do head = NULL in print and expect that to be reflected outside print .

So, any of the following changes are all reflected outside the function:

// pick one:
ptr->data = 20;
ptr->next = NULL;
ptr->next = malloc(sizeof(node));
ptr->next->data = 20;
// etc.

The following aren't :

ptr = NULL;
ptr = malloc(sizeof(node));