传递给函数的struct指针

Question

I have trouble understanding pointers being passed to the function. Here there's a struct pointer, which is passed to a function and the pointer is incremented by some value and it doesn't get reflected in the pointer variable. I guess this is call by value but how? Can you please explain?

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

typedef struct node{
    int data;
}node;

void change_addr(node *ptr){
    ptr += 10;
    printf("Inside Address : %p\n",ptr);
}

int main(){
    node x = {100};
    printf("Address : %p\n",x);
    change_addr(&x);
    printf("Address : %p\n",x);
    return 7;
}

Answer 1

You pass the address of the struct into the function. This argument is incremented within the function and not accessible from the outside. Similar to what would happend if you'd pass and integer and increment it inside the function. If you want to increment data then you need to access it through the pointer passed into the function. For example node->data = 0; which is equivalent to (*node).data = 0; .

&node is the address of the node struct. This parameter is pushed onto the call stack before writing the return address and jumping to the function. See this explanation of the C calling convention . change_addr() can now read and write this value without the main() ever seeing the value, because it's popped from the stack after the execution of change_addr() is finished.

Answer 2

The declaration

node x = { 100 };

allocates memory for a node structure, and initializes it. The statement

change_addr(&x);

takes the memory address of that structure, which is just a number like, say, 1000, and passes it by value into the change_addr() function. Inside that function, you add 100 to your local copy of the pointer, named ptr , which makes it point to an area of memory far beyond where x is located (if x had been an array rather than a single struct, it would point to the 101st element). You then return, which discards your local copy of the address, and returns to your initial stack frame where x was never modified.

Inside the change_addr() function, you could have changed the content of the structure by accessing it through the pointer. For example, ptr->data = 200 would have changed its data. But if you want change a pointer address itself for some reason, then you'd have to create a pointer to the pointer, and pass that to a function taking the appropriate argument type.