Contents

1 About this module

• Prerequisites: 0012, 0065
• Objectives: This module discusses the concepts of local variables and parameters of subroutines.

2 Local variable

We are already discussed variables in module 0012. In this module, we will talk about local variables.

2.1 The concept

A local variable is visible only from within the subroutine that contains it. Because of this property, multiple subroutines can contain local variables of the same name.

This property may not seem very important for now. However, when you need to handle programs with 100s or 1000s of thousands of lines, the last thing you want to worry is whether a variable is shared between two subroutines.

In terms of notation, we can define local variables (in pseudocode) just by saying “local varname”, where varname should be replaced by the name of an actual variable.

2.2 A simple example

Here is a simple example:

Because local variables are local to to each subroutine, the output of this program is “xxxx”. However, if the variable “i” is not local to each subroutine, then what will the program output?

2.3 Tracing a local variable

Tracing a program with local variable is not too different from a program with subroutines. The main difference is that instead of just creating a column for the return line number, we also create a column for the local variable(s). The trace of 1 is in table 1.

Note that local variables do not start with any particular value. A local variable must be initialized before it is read.

3 Parameters

A parameter is a method to pass data to a subroutine. A subroutine may include parameters. When such a subroutine is invoked, each parameter must be “filled” by an argument. An argument is supplied by the invoking code. There are two types of links between an argument and its parameters.

3.1 By value

3.1.1 The concept

One type of parameter is called “pass by value” parameters. Such a parameter is almost like a local variable, except the initial value of such a local variable is specified by the matching argument.

Other than that, a by-value parameter behaves much like a local variable. It can only be seen inside the subroutine that defines it, it is allocated storage only when a subroutine is invoked, and it loses storage as soon as the subroutine returns.

The notation in our pseudocode defines a parameter by the keywords “byval param-name”.

3.1.2 An example

Let us modify algorithm 1 to use parameters in sub1. We will eliminate sub2 and just invoke sub1 multiple times from the “main program”.

In this example, we use parameter $n$ in sub1 to specify how many “x” to print. Note that we use $n$ to specify the end value of $i$ in the loop.

Note that when we invoke sub1, we need to specify what value specifies the initial value of a parameters. This is why we have the notation $2\to n$ on line 11 to specify that parameter $n$ should start with an initial value of 2. The use of the right arrow ($\to$) indicates that information is flowing only one way (to parameter $n$).

Note that the left hand side of the $\to$ symbol is specified by the invoking code, whereas the right hand side of the $\to$ symbol specifies a parameter of the called subroutine.

3.1.3 Trace

To trace a subroutine with a parameter is not much different from tracing a subroutine with a local variable. The main difference is that a by-value parameter starts with a value specified by the invoking statement, whereas a local variable does not start with any particular value.

The trace of algorithm 2 is listed in table 2.

3.2 By reference

3.2.1 The concept

Passing parameters by reference is a little bit tricky. Instead of using the technical term “by reference”, let us use the less formal term “by alias”.

A parameter is that passed by reference (alias) is, well, an alias of something else. This means when we read from such a parameter, we are reading from something else. Similarly, when we write to such a parameter, we are writing to something else.

This make by-reference parameters useful for modifying variables that belong to someone else. In other words, it make the effect of a subroutine cross the “end define sub” boundary.

The notation of such a parameter in our pseudocode is “byref param-name”.

3.2.2 An example

Let us consider a relatively simple example. We are writing a subroutine to initialize a variable to 0. Algorithm 3 is an algorithm based on this subroutine.

In this example, $mainvar$ is a variable that is local to the main program. This means this variable is not visible from the subroutine. When we invoke init0, we need to specify that argument $mainvar$ specifies what parameter $x$ is an alias of. The use of the double arrow ($\leftrightarrow$) indicates that information can flow both ways. Whatever happens to $x$ happens to $mainvar$, but any attempt to read $x$ is actually reading $mainvar$.

Note that the left hand side of the $\leftrightarrow$ symbol is specified by the invoking code, whereas the right hand side of the $\leftrightarrow$ symbol specifies a parameter of the called subroutine.

3.2.3 Trace

The trace of algorithm 3 is short. However, it is deceptively simple because the concept of passing by reference is very different from the concepts of local variables and passing by value.

Table 3 is a trace of algorithm 3.