Subroutine Parameters

Suppose you have written 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, 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. A parameter is a value passed to a subroutine so that one fixed procedure can handle different inputs. The procedure stays the same. The value changes from call to call.

Many programming tasks are the same from one run to the next, but the details change each time. Printing a list of numbers is a good example. The act of printing never changes, yet which numbers appear depends on the situation. Rewriting the subroutine for every variation would be wasteful, so we give it a way to receive the details it needs at the moment it is called. This article introduces that mechanism through a problem we have already met: the 3N+1 sequence.

Recall the rule that generates a 3N+1 sequence. Begin with a number N. If N is odd, replace it with three times N plus one. If N is even, replace it with N divided by two. Keep applying this step until N becomes 1. Starting from N equal to 3, the steps produce 3, 10, 5, 16, 8, 4, 2, 1.

Now take the job we want a subroutine to do: print out such a sequence. The job itself is fixed. The subroutine always follows the same rule. What changes from call to call is the number the sequence begins with. Two different starting values produce two different printed lists, even though the procedure that produces them is identical.

Work through a second starting value by applying the rule step by step. Starting from 6, which is even, the next value is 3. Three is odd, so the next value is 3 times 3 plus 1, which is 10. From there the sequence continues 5, 16, 8, 4, 2, 1. Notice that the procedure never changed: only the first value you fed into it was different.

The parameter is named in the subroutine's header, and that name is used inside the body. The header below is an illustration written for this article, not a listing from the source textbook. Its header names a parameter called n, and the body applies the 3N+1 rule to whatever value that name holds when the function runs. The function prints the whole sequence as a list, so the caller only has to supply the starting value.

It helps to separate two roles. The caller decides which starting value to use and hands it over. The subroutine receives that value and uses it to carry out the fixed procedure. Once the subroutine finishes its job, control returns to the caller, which continues with the rest of the program. The same subroutine can serve many different purposes, because the purpose is determined by what arrives rather than by a rewritten body.

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. The entire array of values travels into the subroutine as a single parameter, and the subroutine has access to all of the values through that one parameter.

Consider a concrete need. Imagine a subroutine whose 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. The subroutine has to know which array to display. The way to tell it is to give the subroutine a parameter of type int[ ], the notation for an array of integers. The caller supplies the array when it makes the call, and the subroutine works on that array.

The printing task has a precise formatting rule. A subroutine that prints an array neatly must handle the separators carefully: no comma before the first value, a comma before each later value, and brackets around the whole list. The loop in the example above follows exactly that rule, which is why the output has no leading comma and no trailing comma.