Swap using Pointers [closed] - c

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 6 years ago.
Improve this question
In the code below in order to swap between px and py you need a pointer to point to the address of py and px to swap them effectively.
My question is with the int temp when the value of px is put into it how does it give the correct value back because there is no pointer pointing to it to be able to give the right value and how is the address of int temp not clone to give a wrong value?
void swap(int px, int py)
{
int temp;
temp = px;
px = py;
py = temp;
}
//pointer version
void swap(int *px, int *py)
{
int temp;
temp = *px;
*px = *py;
*py = temp;
}

Answer 1

Both functions swap the int values. But does that swap affect the calling code's ints?
With the second swap(), the effect of the swap is seen in the original a,b as that function works with the addresses of the original a,b.
int a = 1;
int b = 2;
swap_version2(&a, &b);
printf("%d %d\n", a, b); // prints 2 1
With the first swap(), the effect of the swapped is not seen in the original c,d. as the swap() function was swapping copies of c,d. Net effect: the first swap function simply wastes time. It does not swap c,d.
int c = 3;
int d = 4;
swap_version1(c, d);
printf("%d %d\n", c, d); // prints 3 4

Answer 2

There are two important things you need to know.
1) When calling a function in C, the arguments are always passed by value. If you make changes inside the functions to the variables holding the passed value, the changes will be lost the moment the function returns. In other words - any change made inside the function can't be seen outside the function.
2) When working with pointer the * operator in front of the pointer means the location pointed to by the pointer. It is called dereferencing the pointer. So if you do *px = 5; you do not change any pointer value! You change the value at the location pointed to by the pointer.
A closer look at your code:
In your first example you have something like:
void swap(int px, int py)
{
int temp;
temp = px;
px = py;
py = temp;
}
int main(void)
{
int x = 10;
int y = 100;
swap(x, y);
printf("%d %d\n", x, y);
return 0;
}
In C everything is passed by value. So when you call swap it is the values 10 and 100 which is passed to the function. It is not the variables x and y. In other words - px and py in the function has nothing to do with the variable x and y in main. This means that any change made to the variables px and py is lost when the function returns and x and y does not change.
Your second example is like this:
void swap(int px, int py)
{
int temp;
temp = *px;
*px = *py;
*py = temp;
}
int main(void)
{
int x = 10;
int y = 100;
swap(&x, &y); // Notice the & operator
printf("%d %d\n", x, y);
return 0;
}
As always we have pass by value. But in this case the values that you pass is the values of two pointer to int. More specific you pass the address of x and y.
Like before you can't change the value that is passed to the function (just like the first example) but you can change the value of whatever the pointer is pointing to.
Here you need to know that * in front of the pointer access whatever the pointer is pointing to.
So doing temp = *px will read the value pointed to by px. In this case it is 10 so temp gets the value 10.
Doing *px = *py reads the value py points to (i.e. 100) and place it where px points (i.e. x in main is now 100).
Doing *py = temp reads the value temp holds (i.e. 10) and place it where py points (i.e. y in main is now 10).
So when the function returns, the value of x and y has been swapped.
Notice that the code never uses a pointer to (aka the address of) temp. The variable temp is just used as an ordinary int.

Answer 3

In this function
void swap(int *px, int *py)
{
int temp;
temp = *px;
*px = *py;
*py = temp;
}
there are swapped values pointed to by px and py. The function does not swap the pointers themselves.
To swap the values pointed to by the pointers you need an intermediate memory where temporary to store the value pointed to by px that will be overwritten by the value pointed to by py.
Thus the function uses local variable temp that temporary stores the value *px.
Pay attention to that in this assignment statement
temp = *px;
the variable temp stores the value pointed to by px that is *px that has type int. It is not the pointer px itself that is assigned to temp.