Programming CS2130 Language Concepts
Unit 10 Function and Procedure Abstractions
Expressions & Commands Revisited Recall that an expression is anything that can be evaluated to produce a value whereas a command modifies program state (the internal state which includes the current values of all program variables and the external state which includes the state of all its input and output streams). In a programming language which maintains a clear distinction between expressions and commands evaluating an expression does NOT modify program state, and executing a command does NOT produce a value. Procedures A procedure declaration names a group of commands which are obeyed when the procedure is called. There is a separation between what a procedure does and how it does it; thus procedures provide abstraction over commands. If given meaningful names, use of procedures can improve program clarity, Procedures return no value; the entire purpose of calling a procedure is to modify program state. In the C family of languages (including Java) there are no procedures as such, but functions returning void fulfill the same rle as procedures. Functions A function definition establishes name for a program entity which, when called, returns a value (of a specific type) which usually depends on one or more argument values. Functions fulfill the same general rle as expressions, but hide the details of the calculation of a value behind the name of the function. There is a separation between the function value and the details of the way in which the value is calculated. Functions thus provide abstraction over expressions and, if given meaningful names, can improve program clarity, for example instead of:
if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') ...
we have
if (isLetter(ch)) ...
where
boolean isLetter(char c) { return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'); }
Parameters The term subprogram refers to procedures, functions and Java methods. Without parameters subprograms (procedures and functions) support abstraction only via naming a group of commands. Parameters make the abstraction more powerful through generalisation allowing the subprogram to perform differing tasks depending on the parameters supplied in the subprogram call. For example instead of a procedure sorting a specific array we can write a procedure to sort any array with a parameter specifying the particular array to be sorted when the procedure is called.
A Barnes, 2006
1
CS2130/Unit 10
We can identify three different categories of subprogram parameter: IN mode parameters which are used to pass values into the subprogram from the caller. The subprogram will presumably use these values to perform varying actions and/or to calculate new values from the values passed in. OUT mode parameters which are used to pass values from the subprogram to the caller of the subprogram. The values are produced in some way inside the subprogram and passed bacvk to the caller of the subprogram which will use these values in some way. IN OUT mode parameters which are used to pass values from the caller into the subprogram which modifies these values in some way and then passes the modified values back to the caller. For functions there is, of course, another method of passing a value from the function to its caller: namely via the return value. However this has one major restiriction: only one value can be returned Not all programming language support all the above parameter modes. C basically only has IN mode parameters and function return values. Values1 can be passed into C functions via parameters, but values cannot be passed out of the function via parameters. The only way to get a calculated value back from a C function is via the function return value. For primitive types (int, float, char etc.), Java supports only IN mode parameters and such values can only be passed back to the caller via the function return value mechanism. For reference types (objects and arrays etc.) Java parameters behave like IN OUT mode parameters; the state of an object passed to a Java method can be modified. A new object created by a Java method cannot be passed back to the caller of the method via parameters, but only via the function return mechanism. C++ and Pascal have two kinds of parameter: IN mode parameters and also VAR mode parameters which fulfill the roles of OUT and IN OUT mode parameters. Languages such as Eiffel and Ada explicitly support IN, OUT and IN OUT mode parameters. Parameter Passing Methods An argument is a value that is passed to a subprogram abstraction. An identifier used within a subprogram (procedure or function) abstraction to denote an argument is called a formal parameter. A literal, variable or expression which is evaluated in a subprogram call to yield an argument is called an actual parameter. When a subprogram is called each formal parameter becomes associated with an actual parameter. For example, in the function
boolean isLetter(char c) { return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'); } c
is a formal parameter (of type char). In the following fragment:
char a = `B;
1
Except for array parameters which behave like IN OUT mode parameters in C and C++.
2 CS2130/Unit 10
A Barnes, 2006
...... if (isLetter(a)) ...... a
is an actual parameter which evaluates to give the argument `B'.
Different languages provide differing parameter mechanisms for associating actual and formal parameters. Value Parameters or Copy-in Parameters On entry to a subprogram storage is allocated by a formal parameter X (say), the corresponding actual parameter (which may be any expression) is evaluated and the resulting argument (value) copied to X. We say the parameter is passed by value. Thereafter the parameter behaves just like a local variable: its value may be inspected and updated. However its updating has no effect on the actual parameter or indeed on any non-local entities. In Pascal, Modula-2 and C++ parameters are by default value parameters. In C all parameters (except array parameters) are value parameters.
Actual Parameter Value Value copied on subprogram call Reference Value Value Cell
Formal Parameter X
For example consider the following gcd function in C, C++ or Java:
int gcd(int a, int b) { int r; if (a < 0) a = -a; if (b < 0) b = -b; while (b != 0) { r = a % b; /* remainder */ a = b; b = r; } return a; }
If we call the gcd function (or method) in a step such as
int result = gcd(c, d);
then the values of the actual parameters c and d are copied to the formal parameters a and b. The assignments to a and b b in the body of gcd do NOT alter the actual parameters c and d as a and b originally hold copies of c and d.
A Barnes, 2006
3
CS2130/Unit 10
Result Parameters or Copy-out Parameters On entry to a subprogram storage is allocated by a formal parameter X (say), but its initial value is undefined. On exit from the subprogram the value of X is copied to the corresponding actual parameter which must therefore have a left-value (i.e. it must be a variable, array element or other entity denoting an updateable storage location). In Ada OUT parameters of non-composite types (that is primitive types and pointer types) are result parameters.
Actual Parameter Name Reference Value Cell Value Value copied as subprogram returns Reference Value Value Cell
Formal Parameter X
For example consider the following Ada procedure which finds the largest and smallest values stored in an array:
TYPE IntArray IS ARRAY(1 .. 100) OF Intger; PROCEDURE MaxMin(A : IN IntArray; Max : OUT Integer; Min : OUT Integer) IS BEGIN Max := A(1); Min := A(1); FOR I IN 2 .. 100 LOOP IF A(I) > Max THEN Max := A(I); END IF; IF A(I) < Min THEN Min := A(I); END IF; END MaxMin;
If we call the MaxMin procedure in a code fragment such as
Largest, Smallest : Integer; MyArray : IntArray; ...... MaxMin(MyArray, Largest, Smallest);
The elements of the array are inspected and the largest and smallest values stored in the formal parameters Max and Min. These values are copied to the actual parameters Largest and Smallest just before the procedure call returns. Note that by using OUT parameters multiple values (two in this case) can be passed by to the caller of the procedure whereas with a function return value only one value can be passed to the caller.
A Barnes, 2006
4
CS2130/Unit 10
Value-Result Parameters or Copy-in/Copy-out Parameters The above two mechanisms are combined: on entry to a subprogram storage is allocated by a formal parameter X (say), the corresponding actual parameter is evaluated and the value copied to X.. On exit from the subprogram the final value of X is copied to the corresponding actual parameter which must therefore have a left-value. In Ada IN OUT parameters of noncomposite types are value-result parameters.
Actual Parameter Name Reference Value Cell Value Value copied as subprogram returns Value Value Cell
Formal Parameter copied X
Value on subprogram call
Reference
For example the following Ada procedure might be used to adjust a price by adding VAT at the rate of 17.5%:
PROCEDURE AddVAT(Price : IN OUT Float) IS VATRate : CONSTANT Float := 0.175; BEGIN Price := Price*(1.0 + VatRate); END AddVAT;
If we call the AddVAT procedure in a code fragment such as
ItemPrice : Float := 35.99; ...... AddVAT(ItemPrice); -- price before VAT
The value (35.99) of the actual parameter ItemPrice is copied to the formal parameter Price as the procedure is called, this value is modified inside the procedure (to add VAT at the rate of 17.5%) and then the modified value is copied back to the formal parameter ItemPrice as the procedure returns. Constant Parameters In this case the formal parameter X (say) is bound directly to the value of the corresponding actual parameter as the subprogram is called and the binding remains in effect until the subprogram returns. Hence the value of X remains constant throughout each individual subprogram call. In Ada IN parameters have the semantics of constant parameters; however for non-composite types the actual implementation method is a copy-in mechanism to a nonupdateable storage location X rather than a direct value binding. To see the difference between value parameters and constant parameters consider the following coding of the GCD function in Ada:
FUNCTION GCD(A, B : IN Integer) RETURN Integer IS R : Integer; BEGIN IF A < 0 THEN A := -A; END IF; -- illegal assignment to IN par IF B < 0 THEN B := -B; END IF;
A Barnes, 2006
5
CS2130/Unit 10
WHILE (B /= 0) LOOP R := A REM B; /* remainder */ A := B; B := R; END LOOP; RETURN A; END GCD;
This will not compile as in several places assignments are made to the IN mode parameters A and B. To code the function correctly A and B need to be copied to local variables as in
FUNCTION GCD(A, B : IN Integer) RETURN Integer IS R : Integer; X : Integer := A; Y : Integer := B; BEGIN IF X < 0 THEN X := -X; END IF; IF Y < 0 THEN Y := -Y; END IF; WHILE (Y /= 0) LOOP R := X REM Y; /* remainder */ X := Y; Y := R; END LOOP; RETURN X; END GCD;
Variable Parameters or Reference Parameters In this case the argument is a reference to the storage location associated with the actual parameter; the formal parameter X (say) is bound to the storage associated with the actual parameter which must have a left-value. Thus for the duration of the subprogram call, X and the actual parameter refer to the same storage location and any updating of X is therefore an updating of the associated actual parameter. In effect the address of the actual parameter is passed to the subprogram which can then update the actual parameter directly. In Pascal and Modula-2 VAR parameters are reference parameters as are reference parameters in C++. In C++ reference parameters are denoted by appending an ampersand character to the parameter type in the function declaration. In C and C++ array parameters are in effect reference parameters.
Actual Parameter Name Reference Value Cell Value
Formal Parameter X Reference
Although the Ada standard specifies that parameters of primitive types such as Integer, Float etc. and pointer types are passed by copying, it does not define the parameter passing mechanism for composite types such as arrays and records. The implementor of an Ada
A Barnes, 2006 6 CS2130/Unit 10
compiler may choose to use a copying or a reference mechanism (or a mixture of the two). For efficiency reasons modern implementations tend to use parameter passing by reference. For tagged record types (used in OO Ada programming) the standard specifies that the reference mechanism must be used. Note that whether a reference or copy-in mechanism used for IN mode parameters, constant semantics are enforced by the compiler which prevents any assignments to the parameter within the subprogram body. Thus the situation in Ada can be summarised in the following table Parameter Mode
IN OUT IN OUT
non-composite type
composite type
tagged type reference (constant semantics) reference reference
value value or reference (constant semantics) (constant semantics) result result or reference value-result value-result or reference
Example The difference between value and reference parameters (VAR) is illustrated below: Pascal
PROCEDURE swap(x, y : Integer); VAR tmp : Integer; BEGIN tmp := x; x := y; y := tmp; END; ....... swap(a, b);
C++
void swap(int x, y) { int tmp; tmp = x; x = y; y = tmp; } ....... swap(a, b);
In the above code value parameters are used so the procedure swap copies the contents of variables a and b to x and y and then swaps the copied values. Hence it has no effect on the values of the variables a and b themselves. To code the procedure correctly reference parameters must be used Pascal
PROCEDURE swap(VAR x, y : Integer); VAR tmp : Integer; BEGIN tmp := x; x := y; y := tmp; END; ....... swap(a, b);
C++
void swap(int& x, y) { int tmp; tmp = x; x = y; y = tmp; } ....... swap(a, b);
Here reference parameters are used and so the in the call parameters x and y are bound to the same locations as variables a and b respectively. Hence any change to the parameter x updates the variable a and similarly for y and b. In Ada the analogue of the above code using IN parameters would be illegal as such parameters have constant parameter semantics. To work correctly the procedure would need to use IN OUT p...