Arrays of Integers

Imagine a subroutine that prints a line of output. Every time the program calls it, the same line appears. That is useful, but limited. Most useful subroutines need to know something about the situation they are working in: which number to display, which list to process, or which label to attach to a result. A subroutine parameter is the mechanism that supplies that information. The caller hands a value to the subroutine, and the subroutine uses that value while it does its job.

Keep this question in mind as you read: if the caller can choose the input on every call, how can one piece of code produce different results? The answer follows from the way a parameter carries information into the subroutine.

Consider a concrete need. A subroutine's job is to display every value in an integer array in a neat format: the values separated by commas and wrapped in a pair of square brackets. Before writing it, trace what has to happen. The caller makes the call and supplies an array. The subroutine receives that array through its parameter. It then prints an opening bracket, prints each value with the separators handled correctly, and prints a closing bracket. Control then returns to the caller.

The sequence matters. The argument must be supplied at the moment of the call, because the subroutine can only work on the array it was given. The printing happens inside the subroutine's own work, and only after that work finishes does control go back to the caller.

A parameter does not have to hold a single number or a single word. Its type can be an array type. When that happens, the caller does not pass the array's elements one at a time. Instead, the entire array of values travels into the subroutine as a single parameter. The subroutine then has access to all of the values in that array through its one parameter.

The subroutine has to know which array to display, and the way to tell it is to give it a parameter of type int[ ]. The caller supplies the array when it makes the call, and the subroutine works on that array. The positions of the values run from 0 up to the array's length minus one, and a loop can visit each position in turn.

The following routine is a generated illustration of the task described above. It takes one int[ ] parameter, prints an opening bracket, prints each value with a comma before every value except the first, and prints a closing bracket. The commas are handled by a single check inside the loop, which is the careful separator handling the task requires: no comma before the first value, and a comma before each later value.

The printArray routine does not change between calls. What changes is the input the caller passes. A subroutine parameter lets the same subroutine perform its task on different inputs, with the caller choosing the input on each call. Two calls with different arrays therefore produce two different lines of output from one piece of code.

Notice that the second call does not require a second routine. The caller changed only the argument. This is the reuse that parameters make possible: one subroutine, written once, serves every array the caller hands it.

A subroutine's task is always a subtask of some larger program. A program that does a complicated job is usually divided into smaller pieces, and each piece is handled by a subroutine that does one clearly described thing. The printArray routine is one such piece: a program that, say, computes and reports results can hand the reporting work to this subroutine.

Deciding how to split a large job into those pieces is a separate design skill from writing any single piece. This article focuses on writing the pieces. How the pieces fit together into a whole program is a question that comes back later in the course.