Why should I target the address and not the actual variable name when swapping values of two variables using functions? [duplicate]

b = a copies the value of a to b.

*b = *a copies the value in the memory pointed to by a to the memory pointed to by b.

When a and b are int * they contain the memory address of an integer, a pointer. In this case b = a will simply make b point at the same memory as a. *b says to "dereference" b and use the value it is pointing at. So *b = *a says to copy the value that a is pointing at to the memory b is pointing at.

This is all necessary because you are working inside a function isolated from the rest of the code. That function wants to change the value of two variables outside its scope, so it must do that by manipulating their memory.

int *a, int *b is like having two buckets named a and b. b = a makes buckets a and b the same. *b = *a copies what's in bucket a to bucket b. swap wants to swap what's in x and y's buckets.

Had you passed by value like so...

swap(x, y); void swap(int a, int b) { int t; t = b; b = a; a = t; } 

The values of x and y would be copied to a and b. The values of a and b would be swapped to no effect on x and y.

Had you passed pointers, but not dereferenced, like so...

swap(&x, &y); void swap(int *a, int *b) { int *t; t = b; b = a; a = t; } 

Now the memory address of x and y are copied to a and b. a points to the same memory as x, b points to the same memory as y. But b = a swaps these addresses between a and b to no effect on x and y.

swap(&x, &y); void swap(int *a, int *b) { int t; t = *b; *b = *a; *a = t; } 

The memory address of x and y is still copied to a and b. a has the address of x, b has the address of y. *b = *a changes the value of the memory they point to, the same as y and x. It is effectively y = x. x and y see the change.

Consider the following program

#include <stdio.h> void f( int x ) { x = 20; printf( "Within f( int ) x = %d\n", x ); } int main(void) { int x = 10; printf( "Before call of f( int ) x = %d\n", x ); f( x ); printf( "After call of f( int ) x = %d\n", x ); return 0; } 

The program output is

Before call of f( int ) x = 10 Within f( int ) x = 20 After call of f( int ) x = 10 

As you can see the variable x declared in main was not changed by calling the function.

The variable x was passed to the function f by value. That is the function parameter x (another variable that has the function block scope) was initialized by the value of the variable x declared in main.

So the function changed its local variable (parameter) x. The variable x declared in main stays unchanged.

You can imagine the function definition and its call the following way

f( x ); //... void f( /*int parameter_x*/ ) { int parameter_x = x; patameter_x = 20; printf( "Within f( int ) patameter_x = %d\n", patameter_x ); } 

To change the variable x declared in main you have to pass it by reference. In C passing by reference means passing an object indirectly through a pointer to it.

Here is a demonstrative program.

#include <stdio.h> void f( int *px ) { *px = 20; printf( "Within f( int ) x = %d\n", *px ); } int main(void) { int x = 10; printf( "Before call of f( int ) x = %d\n", x ); f( &x ); printf( "After call of f( int ) x = %d\n", x ); return 0; } 

The program output is

Before call of f( int ) x = 10 Within f( int ) x = 20 After call of f( int ) x = 20 

Dereferencing the pointer px

 *px = 20; 

the function gets a direct access to the pointed object that is to the object x declared in main.

So if you want to exchange values of two variables declared in main within a function like swap you need to pass the corresponding objects by reference to the function. Otherwise the function will deal with copies of values of the variables declared in main.

Abstracting from dupe this swap has minimal sense. Use macro:

#define SWAP(a,b,type) do{type c__c__c; c__c__c = (a); (a) = (b); (b) = c__c__c;}while(0)