Trying to understand a function to swap two int values - c

Question

I know this function swaps two int values, but I'm trying to understand it
minutely what is *x=*y exactly doing.
1 void swap (int* x, int* y){
2 int temp = *x;
3 *x = *y;
4 *y = temp;
5 }
6
7 int x,y;
8 x = 1;
9 y = 2;
10 swap(&x,&y)
The function receives two addresses, where x and y lives, correspondingly.
An int variable, temp, is created and is assigned the value 1 from a dereferenced pointer to x.
The value 1 from a dereferenced pointer to x is assigned the value 2 from a dereferenced pointer to y. So, by *x = *y, I'm reading 1=2
Thanks a lot.

Answer 1

Let's try to explain *x = *y; without using the word "dereference":
*x represents the integer object pointed to by x. As it is the left operand of the assignment, it means that this integer object is going to be updated.
*y represents the integer object pointed to by y. As it is the right operand of the assignment, it means that the content of the integer object (i.e. its value) is going to be used.
*x=*y updates the integer object pointed to by x with the integer object pointed to by y.
Note: To clearly distinguish pointers from other types in the code, I suggest you to change naming as follows, using a prefix like p_ for pointer variables for example:
1 void swap (int* p_x, int* p_y){
2 int temp = *p_x;
3 *p_x = *p_y;
4 *p_y = temp;
5 }
6
7 int x,y;
8 x = 1;
9 y = 2;
10 swap(&x,&y)

Answer 2

When you assign something like int abc = 5; int *ptr = &abc; understand that :
ptr is an integer pointer
&abc is the address of the variable abc
ptr stores addresss of the variable abc
Writing *ptr is the equivalent to writing abc, and not same as writing 5 (a constant), although all three evaluates to 5 in an expression.
The * operator dereferences to give you the the variable , whose address is pointed to by ptr (i.e abc). Therefore it can be used as an lvalue(on the left side of an assignment).
Now in your example, when you tried the assignment x = *y you are trying to store the value pointed to by y ( which is an integer value) to x (which expects an address).
Now assume you somehow made the assignment, let us also assume that &y(i.e address of y ) is something like 1056(only for example sake) and value pointed to by y is something like 5. Then from now on x points to the address location 5 (which is not the actual address), thereby resulting in some garbage value.
Now an assignment like x = y would work flawlessly. But that would make the pointers x point to same location as pointed by y swap their pointing. That is if initially if x was pointing to variable a which was at address 1000 and y was pointing to a variable b which was at address 2000 , after the assignment valu of both x and y would be 1000. It only means that now we have two pointers to the variable b at address 2000, but has no impact on the actual variables.
Whereas writing *x = *y is equivalent to writing a = b
Hope this helped.

Answer 3

Here in swap(&x, &y); you are passing the addresses of variable x & y as arguments to the function swap(int* x, int* y).
As parameters of swap function are int pointers, the addresses of x and y are now stored in another int pointer type variables x and y.
NOTE:
x and y coincidently have the same name in both the functions but the x and y used in swap function are int pointers and the x and y used outside the swap function are int variables.
The value 1 from a dereferenced pointer to x is assigned the value 2 from a dereferenced pointer to y. So, by *x = *y, I'm reading 1=2
*x=*y is actually using an assignment operator with a left to right associativity. assignment operator assigns the value of right operand to the left operand.don't read it as 1=2, it will as it may prove to be problematic later.
I tried to make some assumptions. By *x = *y, I think *x is not dereferencing x, but is the adress of x, and this is getting assigned the value 2 of the dereferenced pointer to y.
*x=*y here, *x is the value of x and not the address of x and as described in point 3, this statement will assign the value of *y i.e. 2 to *x.
But why, instead of *x=*y, shouldn't it just be x=*y?
it shouldn't because x is an int pointer and *y is an int variable.