Theory of Programming Languages
1
Subprograms
2
Topics
1. Introduction
2. Fundamentals of Subprograms
3. Design Issues for Subprograms
4. Parameter-Passing Methods
3
1. Introduction
• Two fundamental abstraction facilities
– Process abstraction
• Emphasized from early days
– Data abstraction
• Emphasized in the1980s
4
2. Fundamentals of Subprograms
• Each subprogram has a single entry point
• The calling program is suspended during execution of
the called subprogram
• Control always returns to the caller when the called
subprogram’s execution terminates
5
Basic Definitions
• A subprogram definition describes the interface to and
the actions of the subprogram abstraction
• A subprogram call is an explicit request that the
subprogram be executed
• A subprogram header is the first part of the definition,
including the name, the kind of subprogram, and the
formal parameters
• The parameter profile of a subprogram is the number,
order, and types of its parameters
• The protocol (aka signature) is a subprogram’s parameter
profile and, if it is a function, its return type
6
Basic Definitions (Cont.)
• Function declarations in C and C++ are often called
prototypes
• A subprogram declaration provides the protocol, but not
the body, of the subprogram
• 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
7
Procedures and Functions
• There are two categories of subprograms
1. Functions :
– A Function is a method in procedural programming
that returns a value.
– Functions are separated from the main method and
can be called from any other method.
– They can also have parameters passed to them to use
in the body of the function.
– Once a function is created , it can be called as many
times as required.
8
Procedures and Functions
The general syntax for a function is :
modifier return-type function-name(list of parameters)
{
body of function
return value statement
}
9
10
Procedures and Functions
2. Procedures :
– A procedure is a method in procedural programming
which does not return a value to main or any other
method.
– Parameters can also be passed to a procedure.
– Like a function these parameters can also be used in
the body of the method.
– Procedures can also be called as many times you
need them.
11
Procedures and Functions
2. Procedures :
– The syntax for a procedure is :
modifier void Procedure-Name( Parameter-list )
{
body of procedure
}
12
Actual / Formal Parameter Correspondence
• Positional Parameters
– The binding of actual parameters to formal parameters is
by position: the first actual parameter is bound to the first
formal parameter and so forth
– Safe and effective
Example
xyz(a, b, c);
. . .
void xyz (int x, int y, int z) {
. . .
}
13
Actual / Formal Parameter Correspondence
• Keyword Parameters
– The name of the formal parameter to which an actual
parameter is to be bound is specified with the actual
parameter
– Advantage: Parameters can appear in any order, thereby
avoiding parameter correspondence errors
– Disadvantage: User must know the formal parameter’s
names
• Example :
xyz ( x = b, z = a, y = c );
14
Formal Parameter Default Values
• In certain languages (e.g., C++, Python, Ruby, Ada, PHP),
formal parameters can have default values (if no actual
parameter is passed)
e.g. void fun(int a=1, int b = 2) { } // definition
…….
void fun(); // function call
– In C++, default parameters must appear last because
parameters are positionally associated.
– e.g. void fun(int a, int b , int c=3) { }
• ………
void fun(1,2);
15
• Variable numbers of parameters
– C# methods can accept a variable number of parameters
as long as they are of the same type—the corresponding
formal parameter is an array preceded by params
• Variable numbers of parameters
– In Ruby, the actual parameters are sent as elements of a
hash literal and the corresponding formal parameter is
preceded by an asterisk.
– In Python, the actual parameter is a list of values and the
corresponding formal parameter is a name with an
asterisk
16
C# Example
public void DisplayList(params int[ ] list) {
foreach (int next in list) {
Console.WriteLine(“Next value {0}”, next);
}
}
-----------------
Myclass myObject = new Myclass();
int[ ] myList = new int[6] {2, 4, 6, 8, 10, 12};
-----------------
myObject.DisplayList(myList);
myObject.DisplayList(2, 4, 3 * x – 1, 17);
17
Design Issues for Subprograms
• What parameter passing methods are provided?
• Are parameter types checked (actual vs. formal)?
• Are local variables static or dynamic?
• Can subprogram definitions appear in other
subprogram definitions (nested)?
• Can subprograms be passed as parameters?
• Can subprograms be overloaded?
• Can subprogram be generic?
18
Models of parameter passing
19
Semantic models of parameter passing
• Formal parameters are characterized by one of these
distinct semantics models
In mode : They can receive data from the corresponding
actual parameter.
Out mode : They can transmit data to the actual parameter
Inout mode : They can do both.
20
Conceptual models of transfer
• There are two conceptual model of how data transfers
take place in parameter transmission:
• Either an actual value is physically moved (to the
caller, to the callee, or both ways) or an access path
is transmitted.
21
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
22
Pass-by-Value ( In Mode)
• The value of the actual parameter is used to initialize the
corresponding formal parameter.
• It implements in-mode semantics.
– Normally implemented by copying
– Can be implemented by transmitting an access path but
not recommended.
– When copies are used, additional storage is required
– Storage and copy operations can be costly when data is
large
23
Pass-by-Result ( Out mode )
• When a parameter is passed by result, no value is
transmitted to the subprogram; the corresponding 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
– One additional problem with the pass-by-result model
is that there can be an actual parameter collision.
24
Pass-by-Result ( Out mode )
static public void Main()
{
int c; // Value is not assigned to variable c
Fun1(out c); // variable c is passed to the function using out keyword
// Display the value c
Console.WriteLine("The value is: {0}", c);
}
// Function in which out parameter is passed and this function returns the value
of
// the passed parameter
public static void Fun1(out int c)
{
c = 10; Result
c = c + c; The value is 20
}
25
C# Example
void Fixer (out int x, out int y) {
x = 17;
y = 35;
}
...
f.Fixer(out a, out a); // Calling Fixer function
Console.WriteLine(“a = “ + a);
• Output:
a = 35
26
Pass-by-Value-Result ( In out mode)
• A combination of pass-by-value and pass-by-result
• Sometimes called pass-by-copy
– because the actual parameter is copied to the formal
parameter at subprogram entry and then copied back
at subprogram termination.
• Formal parameters have local storage
• Disadvantages:
– Those of pass-by-result
– Those of pass-by-value
27
Pass by Reference (In out mode)
• transmits an access path, usually just an address, to the
called subprogram.
• the called subprogram is allowed to access the actual
parameter in the calling program unit
• Also called pass-by-sharing
• Passing process is efficient (no copying and no duplicated
storage)
• Disadvantages
– Slower accesses (compared to pass-by-value) to formal
parameters because of the additional level of indirect
addressing that is required
– Potentials for un-wanted side effects
28
Pass by Reference (In out mode)
– Un-wanted aliases (access broadened): harmful to
reliability and readability
• There are several ways pass-by-reference parameters can
create aliases.
• First, collisions can occur between actual parameters.
Consider a C++ function that has two parameters that are to
be passed by reference, as in
• void fun(int &first, int &second)
If the call to fun happens to pass the same variable twice, as in
fun(total, total)
then first and second in fun will be aliases
29
• Second, collisions between array elements can also
cause aliases.
• For example, suppose the function fun is called with
two array elements that are specified with variable
subscripts, as in
fun(list[i], list[j])
• If these two parameters are passed by reference and i
happens to be equal to j, then first and second are again
aliases.
30
