Swapping in
C, C++, and Java

Parameters, by value and by reference: Both C and Java use only parameters that pass by value, which means that the value of the actual parameter is used to initialize the formal parameter. For simple variables C allows one to pass the address of the variable explicitly. (Java does not allow this.) This is sometimes called passing a parameter by reference. C++ allows this also, but C++ also allows an implicit pass by reference, which will be described at the end of this writeup.

In C, the mechanism above is what is used for parameters in the scanf function, which have the extra & (the "address of" operator) in front of them.

A swapping values: In C and in Java, we can always swap values with the use of three assignment statement and no function or paramters. The code on the left shows this, while the code on the right shows how the same task can be accomplished using the C exclusive-or operator ^. (Notice that is this case you don't need the variable t.)

C Simple Swap Program -- Assignments C Simple Swap Program -- Exclusive-Or

#include <stdio.h>

int main() {
   int a = 23, b = 47;
   int t;
   printf("Before. a: %d, b: %d\n", a, b);
   t = a;
   a = b;
   b = t;
   printf("After.  a: %d, b: %d\n", a, b);
   return 0;
}


#include <stdio.h>

int main() {
   int a = 23, b = 47;
   
   printf("Before. a: %d, b: %d\n", a, b);
   a ^= b;
   b ^= a;
   a ^= b;
   printf("After.  a: %d, b: %d\n", a, b);
   return 0;
}
Runs of the two programs
% cc -o swap_simple0 swap_simple0.c
% swap_simple0
Before. a: 23, b: 47
After.  a: 47, b: 23

% cc -o swap_simple1 swap_simple1.c
% swap_simple1
Before. a: 23, b: 47
After.  a: 47, b: 23

A swapping function: To understand how explicit pass by reference of parameters works in C, consider implementing a swap function in C, that is, a function that passes in two variables and swaps their values. The code on the left below shows one failed attempt at an implementation. The code on the right uses pointers, that is, explicitly passes the address of variables, and manipulates the numbers that are at that address, using the * operator (the "dereference" operator that fetches the contents of the given address).

C Swap Program -- Fails C Swap Program with Pointers -- Works

#include <stdio.h>

void swap(int i, int j) {
   int t = i;
   i = j;
   j = t;
}

int main() {
   int a = 23, b = 47;
   printf("Before. a: %d, b: %d\n", a, b);
   swap(a,b);
   printf("After.  a: %d, b: %d\n", a, b);
   return 0;
}


#include <stdio.h>

void swap(int *i, int *j) {
   int t = *i;
   *i = *j;
   *j = t;
}

void main() {
   int a = 23, b = 47;
   printf("Before. a: %d, b: %d\n", a, b);
   swap(&a, &b);
   printf("After . a: %d, b: %d\n", a, b);
}
Runs of the two programs
% cc -o swap0 swap0.c
% swap0
Before. a: 23, b: 47
After.  a: 23, b: 47

% cc -o swap1 swap1.c
% swap1
Before. a: 23, b: 47
After.  a: 47, b: 23

With the program on the left, no swapping took place. The values of a and b are passed to swap, and the function does swap them, but when the function returns, nothing has changed in the main function.

To get an idea of what this code does, print it out, draw the two integers a and b, and enter 23 and 47 in them. Now draw the two pointers i and j, along with the integer t. When swap is called, it is passed the addresses of a and b. Thus, i points to a (draw an arrow from i to a) and j points to b (draw another arrow from b to j). Once the pointers are initialized by the function call, *i is another name for a, and *j is another name for b. Now run the code in swap. When the code uses *i and *j, it really means a and b. When the function completes, a and b have been swapped.

Suppose you accidentally forget the & when the swap function is called, and that the swap line accidentally looks like this: swap(a, b);. This causes a segmentation fault. When you leave out the &, the value of a is passed instead of its address. Therefore, i points to an invalid location in memory and the system crashes when *i is used.

This is also why scanf crashes if you forget the & on variables passed to it. The scanf function is using pointers to put the value it reads back into the variable you have passed. Without the &, scanf is passed a bad address and crashes. Reference parameters are one of the most common uses of pointers in C. Another way to say this is to say that the calling function is telling the called function where to find the variable.

Swapping in Java: The swapping just above using reference parameters in C doesn't work in Java, since Java doesn't have these kind of parameters, but often an application really only needs to swap two values in an array. In this case one can pass the array and the two indexes to swap as three parameters, and this will work in Java. The "bubble sort" program below illustrates this.

Java BubbleSort Program Run of the Program
public class BubbleSort {
   // swap: interchange inside array
   static void swap(int[] a, int i, int j) {
      int t = a[i];
      a[i] = a[j];
      a[j] = t;
   }

   // bubbleSort: very short code, but ineffient
   static void bubbleSort(int[] a) {
      for (;;) {
         boolean sorted = true;
         for (int i = 0; i < a.length - 1; i++)
            if (a[i] > a[i+1]) {
               sorted = false;
               swap(a, i, i + 1);
            }
         if (sorted) break;
      }
   }

   static void printArray(int[] a) {
      for (int i = 0; i < a.length; i++) {
         if (i%4 == 0) System.out.println();
         System.out.print(a[i] + " \t");
      }
      System.out.println();
   }

   public static void main(String[] args) {
      int size = Integer.parseInt(args[0]);
      System.out.println("Bubblesort, size = " +
         size);
      int[] r = new int[size];
      for (int i = 0; i < size; i++)
         r[i] = (int)(Math.random()*size*10 + 1);
      long startTime =System.currentTimeMillis();
      bubbleSort(r);
      System.out.println("Elapsed time(millis) "+
         (System.currentTimeMillis()-startTime));
      // printArray(r);
   }
}

% javac BubbleSort.java
% java BubbleSort 60
Bubblesort, size = 60
Elapsed time (millis) 1

5       7       9       18
21      27      41      44
67      104     104     109
116     118     151     151
170     175     181     182
196     196     207     220
231     240     241     242
244     247     251     274
279     290     302     325
329     339     341     363
366     369     376     380
385     411     435     440
471     484     492     504
505     547     556     559
564     583     588     591
% java BubbleSort 100
Bubblesort, size = 100
Elapsed time (millis) 3
% java BubbleSort 1000
Bubblesort, size = 1000
Elapsed time (millis) 394
% java BubbleSort 10000
Bubblesort, size = 10000
Elapsed time (millis) 39518
% java BubbleSort 20000
Bubblesort, size = 20000
Elapsed time (millis) 158317
% java BubbleSort 40000
Bubblesort, size = 40000
Elapsed time (millis) 646717

Swapping in Java Using Wrapped Integers: In Java we can get the swap function to work if we use wrapped integers and pass references to them to the function. However, the Java wrapper class for int is Integer and it doesn't allow you to alter the data field inside. Thus we need our own wrapper class, which I have called MyInteger below. The program here is only presented as what could be done, not as an example of how to do swaps. If one passes the address of an object to a function, then changes to the inside of that object will persist after returning from the function

Java Swapping Using a Wrapper Class

// MyInteger: similar to Integer, but can change value
class MyInteger {
   private int x;                   // single data member
   public MyInteger(int xIn) { x = xIn; } // constructor
   public int getValue() { return x; }  // retrieve value
   public void insertValue(int xIn) { x = xIn;} // insert
}

public class Swapping {
   // swap: pass references to objects
   static void swap(MyInteger rWrap, MyInteger sWrap) {
      // interchange values inside objects
      int t = rWrap.getValue();
      rWrap.insertValue(sWrap.getValue());
      sWrap.insertValue(t);
   }

   public static void main(String[] args) {
      int a = 23, b = 47;
      System.out.println("Before. a:" + a + ", b: " + b);
      MyInteger aWrap = new MyInteger(a);
      MyInteger bWrap = new MyInteger(b);
      swap(aWrap, bWrap);
      a = aWrap.getValue();
      b = bWrap.getValue();
      System.out.println("After.  a:" + a + ", b: " + b);
   }
}

% javac Swapping.java
% java Swapping
Before: a: 23, b: 47
After:  a: 47, b: 23

Swapping in C++: Of course the C swapping methods will work in C++ also, but C++ has the very important concept of references, which we probably won't study in this course. However, below is a C++ swap program using this feature. Notice that the code for the actual swap is simple: swap(a, b);. In a similar way, the simple form of C++ input, such as cin >> x >> y; requires these kind of parameters.

C++ Swap Program Using References

#include <iostream>
using std::cout;

void swap(int& i, int& j) {
    int t = i;
    i = j;
    j = t;
}

int main() {
    int a = 23, b = 47;
    cout << "Before. a: " << a << ", b: " << b << "\n";
    swap(a, b);
    cout << "After.  a: " << a << ", b: " << b << "\n";
    return 0;
}
Run of the program
% CC -o swap_CC swap.cpp
% swap_CC
Before: a: 23, b: 47
After:  a: 47, b: 23

Swapping in C Using the Preprocessor: Another very good way to swap in C (perhaps the best way) uses the C preprocessor, which we will study later. For now, a preprocessor function like swap below does a textual substitution, before the actual compiler is invoked. The second listing below is what is sent to the compiler. (This is why there is no semicolon at the end of swap(int, a, b), since in the compiled code it would become a redundant semicolon at the end of a block (although not an error).)

C Swap Program Using Preprocessor

#define swap(type, i, j) {type t = i; i = j; j = t;}

int main() {
    int a = 23, b = 47;
    printf("Before swap. a: %d, b: %d\n", a, b);
    swap(int, a, b)
    printf("After swap.  a: %d, b: %d\n", a, b);
    return 0;
}
Preprocessed Output

% cc -E swap_p.c
int main() {
    int a = 23, b = 47;
    printf("Before swap. a: %d, b: %d\n", a, b);
     { int t = a ; a = b ; b = t ; }
    printf("After swap.  a: %d, b: %d\n", a, b);
    return 0;
}
Run of the program
% cc -o swap_p swap_p.c
%  swap_p
Before swap: a: 23, b: 47
After swap:  a: 47, b: 23

Copyright © 2011, Neal R. Wagner. Permission is granted to access, download, share, and distribute, as long as this notice remains.