In sorting and other applications, it is useful to be able to swap the values of two variables, such as x1 and y2.

Will the following way work to swap the values of x1 and y2?
x1 = y2; y2 = x1;

Here is the C code [#2]
#include <stdio.h> int main() { int x1; int y2; x1 = 2; y2 = 3; printf("before x1=%d y2=%d\n",x1,y2); x1 = y2; y2 = x1; printf("after x1=%d y2=%d\n",x1,y2); return 0; }

What happened? Why were the values not properly swapped?

Here is the output of the C code.
before x1=2 y2=3 after x1=3 y2=3
The above did not work (unless the values of x1 and y2 are the same). Why not?

Note: It is possible to swap the values without an additional variable but not in just two assignment statements (using expressions without side-effects).

Here is an in-line method to swap the values using a temporary variable z3.
z3 = y2; y2 = x1; x1 = z3;

Here is the C code [#4]
#include <stdio.h> int main() { int x1; int y2; int z3; x1 = 2; y2 = 3; printf("before x1=%d y2=%d\n",x1,y2); z3 = y2; y2 = x1; x1 = z3; printf("after x1=%d y2=%d\n",x1,y2); return 0; }

This way worked.

Here is the output of the C code.
before x1=2 y2=3 after x1=3 y2=2
Let us abstract the above code into a swap procedure.

Here is the C code [#5]
#include <stdio.h> void swap(int a1, int b2) { int c3; c3 = a1; a1 = b2; b2 = c3; } int main() { int x1; int y2; x1 = 2; y2 = 3; printf("before x1=%d y2=%d\n",x1,y2); swap(x1,y2); printf("after x1=%d y2=%d\n",x1,y2); return 0; }
Here is the output of the C code.
before x1=2 y2=3 after x1=2 y2=3
What happened? Why did swap not properly swap the values?

In call by value, the value of the actual parameter is passed to the procedure/function. Since the procedure/function has only the value, the procedure/function cannot directly change the actual value of a variable passed as an actual parameter.

A value parameter is a formal parameter whose corresponding actual parameter value is passed to a procedure or function. If the actual parameter represents a memory location (e.g., a variable), assigning a value to the formal parameter within the procedure or function does not change the contents of the memory location represented by the actual parameter.

Since the swap procedure should change the actual values of the variable passed as an actual parameter, we cannot use call by value.

In call by reference, the memory address of the variable that is the actual parameter is passed to the procedure/function. Since the procedure/function has the memory address of the variable passed as the actual parameter, the procedure/function can change the value of the actual parameter. Explain the primary similarity and difference between call-by-value and call-by-reference.

A reference parameter is a formal parameter whose actual parameter represents a memory location so that assigning a value to the formal parameter within the procedure or function changes the contents of the memory location represented by the actual parameter.

Since the swap procedure should change the actual values of the variable passed as an actual parameter, we need to use call by reference.

Let us now try the above code with swap written using reference parameters.

Here is the C code [#6]
#include <stdio.h> void swap(int *a1, int *b2) { int c3; c3 = *a1; *a1 = *b2; *b2 = c3; } int main() { int x1; int y2; x1 = 2; y2 = 3; printf("before x1=%d y2=%d\n",x1,y2); swap(&x1,&y2); printf("after x1=%d y2=%d\n",x1,y2); return 0; }

Note that to use call by reference in C, the formal parameter name (and usage of the formal parameter) is prefixed with the asterisk "*" while the actual parameter name is prefixed with the ampersand "&".

In call by value, the actual parameter is an expression.

In call by reference, the actual parameter is a variable.

How do you decide whether to use call by value or call by reference for a formal parameter?

Sometimes you are told which method to use.

Sometimes you have no choice (e.g., In c++, structures are always called using call by reference). In general, though, unless the actual parameter is a variable and the value of the variable passed as an actual parameter needs to be changed in the procedure/function, you should use call by value.

In production C/C++ systems, where machine efficiency is very important, a macro text-replacement strategy is often used for swapping values. Here is one way to do this using two variables and replacement and the C feature ignoring issues of overflow or underflow.

Note: This only works for integers. Other types require a more involved macro. Here is the C code [#7]
#include <stdio.h> #define swap(x,y) { x = x + y; y = x - y; x = x - y; } int main() { int x1; int y2; x1 = 2; y2 = 3; printf("before x1=%d y2=%d\n",x1,y2); swap(x1,y2) printf("after x1=%d y2=%d\n",x1,y2); return 0; }
Note: Due to the replacement of swap(x1,y2) with a block (delimited by curly braces), a terminating semicolon can be used or not used. Here is the output of the C code.
before x1=2 y2=3 after x1=3 y2=2
The macro replacement by the preprocessor is a meta-programming process.

Note: You do not need this for this course, but you will often see such macros in production code, on the Internet, etc.