Chapter 9 Subprograms Introduction Fundamentals of Subprograms Local

Chapter 9: Subprograms • • • Introduction Fundamentals of Subprograms Local Referencing Environments Parameter-Passing Methods Type Checking Parameters Design Issues for Functions 1

Introduction • Two fundamental abstraction facilities – Process abstraction • Emphasized from early days->subprogram – Data abstraction • Emphasized in the 1980 s-> Class (ch 11 & 12) • Benefits of subprogram – Process abstraction: • The procedure name like “sort” conveys the intent of the procedure. • focus on what; – implementation hiding: • Only procedures needs to be modified. • easy to modify; – modular program: easy to manage a large program; – libraries: extending a language 2

Fundamentals of Subprograms • Each subprogram has a single entry point • A subprogram call is an explicit request that the subprogram be executed • The calling program is suspended during execution of the called subprogram • Control always returns to the caller when the called subprogram’s execution terminates 3

Procedures and Functions • There are two categories of subprograms – Procedures are collection of statements that define parameterized computations • treated as atomic statements, e. g. , read (ch). – Functions structurally resemble procedures but are semantically modeled on mathematical functions • like operators, which return a result. • called from within expressions, e. g. , r*sin(angle). 4

Basic Definitions • A subprogram definition describes the interface to and the actions of the subprogram abstraction • A subprogram header is the first part of the definition, including the name, the kind of subprogram, and the formal parameters – Ada: – C: Procedure Adder (parameters) void adder (parameters) • The protocol is a subprogram’s parameter profile (including the number, order, and types of its parameters), and, if it is a function, its return type • A subprogram declaration provides the protocol, but not the body, of the subprogram • Function declarations in C and C++ are called prototypes, and often placed in header files. 5

Actual/Formal Parameter • A formal parameter is a dummy variable listed in the subprogram header and used in the subprogram • An actual parameter represents a value or address used in the subprogram call statement • Positional correspondence – the first actual parameter is bound to the first formal parameter, and so forth – Safe and effective • Keyword correspondence – The name of the formal parameter to which an actual parameter is to be bound, is specified with the actual parameter – Parameters can appear in any order – Python example: sumer(length = my_len, list = my_array) 6

Formal Parameter Default Values • In certain languages (e. g. , C++, Ada), formal parameters can have default values (if not actual parameter is passed) – In C++, default parameters must appear last because parameters are positionally associated – Example: float compute_pay(float income, float tax_rate, int exemptions = 1) pay = compute_pay(20000. 0, 0. 15); 7

Local Referencing Environments • Local variables can be stack-dynamic (bound to storage) – Advantages • Support for recursion • Storage for locals is shared among some subprograms – Disadvantages • Allocation/de-allocation, initialization time • Indirect addressing • Subprograms cannot be history sensitive • Local variables can be static – retain their values between activations (Ch 10); the lifetime of a static variable is the entire computation. – Storage for them is allocated statically at compile time; No run-time overhead – More efficient (no indirection) – Cannot support recursion – declared by the keyword static in C. 8

Example of static variables • Consider the following declaration: • int f(int n) { static int count = 0; int result; count = count + 1; if (n == 0) result = 1; else result = n * f(n-1); return result; } A trace showing the values of variables for the call f(3) -> f: n=3; count = 0 -> f: n=2; count = 1 -> f: n=1; count = 2 -> f: n=0; count = 3 <- f: n=0; count = 4; result = <- f: n=1; count = 4; result = <- f: n=2; count = 4; result = <- f: n=3; count = 4; result = 1 1 2 6 9

Parameter Passing Methods • Ways in which parameters are transmitted to and/or from called subprograms – Pass-by-value – Pass-by-result – Pass-by-value-result – Pass-by-reference – Pass-by-name 10

Models of Parameter Passing 11

Pass-by-Value (In Mode) • The value of the actual parameter is used to initialize the corresponding formal parameter. • This method is normally used in Pascal, C, and C#. • Example: In the call square (2+3) -> x : = 2+3; square : = x*x; return 25 • Implementation – Normally implemented by copying – Require additional storage – Storage and copy operations can be costly • This method cannot change the value of the actual parameters 12

Pass-by-Result (Out Mode) • passed by result: – no value is transmitted to the subprogram – the formal parameter acts as a local variable; its value is transmitted to caller’s actual parameter when control is returned to the caller – Require extra storage location and copy operation – in C#: “out” is specified in formal and actual parameters • Example void Fixer(out int x, out int y) {x = 17; y=35; } … f. Fixer(out a, out b); • Potential problem: sub(p 1, p 1); whichever formal parameter is copied back last will represent the current value of p 1 13

Pass-by-Value-Result (inout Mode) • A combination of pass-by-value and pass-byresult • The actual are initially copied into the formals, and the formals are eventually copied back out to the actuals. • Formal parameters have local storage • Sometimes called pass-by-copy • In Ada 95, all scalars are passed-by-copy – Support three parameters: In, out, in out • Disadvantages: – Those of pass-by-result – Those of pass-by-value 14

Pass-by-Reference (Inout Mode) • Pass an access path – A formal parameter becomes a synonym for the location of an actual parameter; • In C# – Pass-by-reference is specified by preceding both a formal parameter and its actual parameter with ref – In Pascal, using “var” with formals (see the next page) • achieved in C using pointers. – The function is defined as follows: void swapc(int *px, int *py) {int z; z = *px; *px = *py; *py = z; } – The procedure call should pass the pointer such as swapc(&a, &b). 15

Pass-by-Reference (cont) • It is achieved in Pascal using the keyword “var”. • Example: procedure swap (var x: integer; var y: integer); var z: integer; begin z : = x; x : = y; y : = z; end; • A call swap (i, A[i]) does the following: make the location of x the same as that of i; make the location of y the same as that of A[i]; z : =x; x: =y; y: =z; • If i is 2 and A[2] = 99; the effect of the call will be: z: = 2; i: =99; A[2] : = z => changed 16

Pass-by-Reference (cont) • Advantage – Passing process is efficient (no copying and no duplicated storage) • Disadvantages – Slower accesses (compared to pass-by-value) to formal parameters, due to indirect addressing – Potentials for un-wanted side effects, which changes the actual parameters – Un-wanted aliases • Example (in C++) void fun(int &first, int &second) The call: fun(total, total) 17

Pass-by-Name (Inout Mode) • By textual substitution • Allows flexibility in late binding – Not at the time of the subprogram call, but when the formal is assigned or referenced • Example (in Pascal): Consider the procedure swap in page 16 without “var”. • A call swap(i, A[i]) yields: z : =i; i: =A[i]; A[i]: =z; • If i is 2 and A[2] = 99, the effect of the call will be: z: = 2; i: =99; A[i] : = z => A[99] is affected, not A[2] -> dynamic binding • It is used in Algol 60 and achieves lexical scope by renaming locals. 18

Type Checking Parameters • Considered very important for reliability • Pascal, FORTRAN 90, Java, and Ada: it is always required • ANSI C and C++: choice is made by the user – Example of avoiding type checking: double sin(x) double x; {…. . } • Relatively new languages Perl, Java. Script, and PHP do not require type checking, since variables (and formal parameters) are typeless. 19

Multidimensional Arrays as Parameters • If a multidimensional array is passed to a subprogram and the subprogram is separately compiled, the compiler needs to know the declared size of that array to build the storage mapping function 20

Multidimensional Arrays as Parameters: C and C++ • Programmer is required to include the declared sizes of all but the first subscript in the actual parameter, to compute the address • Example: void fun(int matrix[][10]) {…} • Disallows writing flexible subprograms • Solution: pass a pointer to the array and the sizes of the dimensions as other parameters; the user must include the storage mapping function in terms of the size parameters • Example: void fun(float * mat_ptr, int num_row, int num_col); . . *(mat_ptr + (row *num_col) + col) = x; 21

Multidimensional Arrays as Parameters: Pascal and Ada • Pascal – Not a problem; declared size is part of the array’s type • Ada – Constrained arrays - like Pascal – Unconstrained arrays - declared size is part of the object declaration • Java and C# – Similar to Ada – Arrays are objects; they are all single-dimensioned, but the elements can be arrays – Each array inherits a named constant (length in Java, Length in C#) that is set to the length of the array when the array object is created 22

Design Issues for Functions • Are side effects allowed? – Ada: Parameters should always be in-mode to reduce side effect • What types of return values are allowed? – Most imperative languages restrict the return types – C allows any type except arrays and functions – C++ is like C but also allows user-defined types – Ada allows any type – Java and C# do not have functions but methods can have any type 23