subprograms l.
Skip this Video
Loading SlideShow in 5 Seconds..
Subprograms PowerPoint Presentation
Download Presentation

Loading in 2 Seconds...

play fullscreen
1 / 42

Subprograms - PowerPoint PPT Presentation

  • Uploaded on

Subprograms. Fundamentals of subprograms Design issues for subprograms Parameter-passing methods Type checking of parameters Static or dynamic storage Local referencing environments Nesting of subprogram definitions Overloaded subprograms Generic subprograms Design issues for functions

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
  • Fundamentals of subprograms
  • Design issues for subprograms
    • Parameter-passing methods
    • Type checking of parameters
    • Static or dynamic storage
    • Local referencing environments
    • Nesting of subprogram definitions
    • Overloaded subprograms
    • Generic subprograms
  • Design issues for functions
  • Subprograms as parameters
  • User-defined overloaded operators

Levels of Control Flow:

  • Among program units (this lecture) – Ch. 9
  • Among program statements – Ch. 8
  • Within expressions – Ch. 7

Two fundamental abstraction facilities

  • Process abstraction – Ch. 9
  • Data abstraction – Ch. 11
fundamentals of subprograms
Fundamentals of Subprograms

General characteristics of subprograms:

  • has a single entry point
  • caller is suspendedduring execution of the called subprogram
  • control always returns to the caller when the called subprogram’s execution terminates

Note: 2. does not apply to concurrent programs

  • Subprogram
    • Description of the subprogram's actions
  • Subprogram call
    • Explicit request to execute the subprogram
  • Subprogram header
    • the 1st part of subprogram's definition: its name, type, and formal parameters
  • Parameter profile
    • the number, order, and types of the formal parameters
  • Subprogram protocol
    • its parameter profile plus, if it is a function, its return type
  • Subprogram declaration
    • its name and its protocol, but not the body
  • Formal parameter
    • “dummy” variable listed in the parameter profile and used in the subprogram body
  • Actual parameter
    • value or address used in the subprogram call statement
actual formal parameter correspondence
Actual/Formal Parameter Correspondence
  • Positional (most common)
  • With keyword
    • e.g.
      • SORT(LIST => A, LENGTH => N);
    • Advantage: order is irrelevant
    • Disadvantages
      • user must know the formal parameter’s names
      • less readable and writeable
  • Default values





subprograms functions and procedures
Subprograms (Functions and Procedures)
  • Formal parameter (names)
  • Actual parameters
  • Passing
    • In
    • Out
    • In/Out






Formal parameters







Side Effects

design issues for subprograms
Design Issues for Subprograms
  • Parameter passing
    • can subprograms be used?
  • Type checking of parameters
    • how strict?
  • Static or dynamic
    • local variable allocation
  • Nesting
    • can subprogram be defined in another subprogram definition?
  • Referencing environment
    • what can be accessed within the caller (sub)program?
  • Overloading
    • is it allowed?
  • Generic
    • can subprogram be generic?
parameter passing methods
Parameter Passing Methods
  • How can parameters be transmitted to and/or from the caller and the called subprogram?
    • Pass-by-value (in mode)
    • Pass-by-result (out mode)
    • Pass-by-value-result (in/out mode)
    • Pass-by-reference (in/out mode)
    • Pass-by-name
parameter passing with physical moves copy
Parameter Passing with Physical Moves (Copy)


(sub(a, b, c))

Callee(void sub (int x, int y, int z))






In mode





Out mode




In/out mode


design choices for parameter passing
Design Choices for Parameter Passing
  • Efficiency vs. style and reliability
  • One-way or two-way parameters?
    • Good programming style
      • limited access to variables, e.g. one-way whenever possible
    • Efficiency
      • pass by reference is the fastest way to pass big structures, however the access is then a bit slower
    • Note the conflict!
    • Also style
      • functions should minimize pass by reference parameters
pass by value in mode
Pass-by-value (In Mode)
  • Physical move (copy)
    • Advantages
      • No need to write-protect in the called subprogram
      • Accesses cost lower (no indirect addressing)
    • Disadvantages
      • Requires more storage (duplicated space)
      • Cost of the moves (if the parameter is large)
  • Access path (reference)
    • Advantages & Disadvantages
      • Opposite of above
pass by result out mode
Pass-by-result (Out Mode)
  • No value is transmitted to the subprogram
  • Local’s value is passed back to the caller
    • Physical move is usually used
  • Disadvantages:
    • If value is passed, time and space
    • Order dependence may be a problem
      • e.g.

procedure sub(y: int, z: int);


sub(x, x);

      • Value of x depends on order of assignments in the callee!!!
pass by value result in out mode
Pass-by-value-result (In/Out Mode)
  • Combination of pass-by-value andpass-by-result
    • Also called pass-by-copy
  • Formal parameters have local storage
  • Physicalmove both ways
  • Advantages/Disadvantages:
    • Same as for pass-by-result
    • Same as for pass-by-value
pass by reference in out mode
Pass-by-Reference (In/Out Mode)
  • Pass an access path (reference)
    • Also called pass-by-sharing
  • Advantage
    • Efficient - no copying and no duplicated storage
  • Disadvantages
    • Slower accesses to formal parameters (than in pass-by value)
    • Potential for unwanted side effects
    • Allows aliasing
      • See next slide
pass by reference aliasing
Pass-by-Reference Aliasing
  • Actual parameter collisions:


procedure sub(a: int, b: int);


sub(x, x);

  • Array element collisions:


      • sub(a[i], a[j]); /* if i = j */
    • Also,
      • sub2(a, a[i]); /* (different one) */
  • Collision between formal parameters and global variables
pass by reference problems
Pass-by-Reference Problems
  • Root cause
    • Subprogram has more access to non-locals than necessary
    • Reference to the memory location allows side effects
  • Pass-by-value-result solves this
    • It does not allow these aliases
    • has other problems
pass by name in out mode
Pass-by-Name (In/Out Mode)
  • By textual substitution
  • Formal parameters are bound to an access method at the time of the call
  • Actual binding to a value or address takes place at the time of a reference or assignment
  • Advantage
    • Flexibility in late binding
  • Disadvantages
    • Reliability: weird semantics
pass by name semantics
Pass-by-name Semantics
  • If actual is a scalar variable, it is pass-by-reference
  • If actual is a constant expression, it is pass-by-value
  • If actual is an array element, it is like nothing else
    • e.g.

procedure sub1(x: int; y: int);


x := 1;

y := 2;

x := 2;

y := 3;


sub1(i, a[i]);

multidimensional arrays as parameters
Multidimensional Arrays as Parameters
  • If a multidimensional array is passed-by-value in a separately compiled subprogram
  • The compiler needs to know the declared size of that array to build the storage mapping function
parameter passing methods of major languages
Parameter Passing Methods of Major Languages
  • Fortran
    • Always used the in/out semantics model
    • Before Fortran 77: pass-by-reference
    • Fortran 77 and later: scalar variables are often passed by value result
  • C
    • Pass-by-value
    • Pass-by-reference is achieved by using pointers as parameters
  • C++
    • A special pointer type called reference type for pass-by-reference
  • Java
    • All primitive type parameters are passed by value
    • Object parameters are passed by reference
parameter passing methods in pls cont
Parameter Passing Methods in PLs (cont.)
  • Ada
    • Three semantics parameter modes
    • in
      • can be referenced but not assigned
    • out
      • can be assigned but not referenced
    • in/out
      • can be referenced and assigned
    • in is the default mode
  • C#
    • Pass-by-value is default
    • Pass-by-reference
      • ref must precede both the formal and its actual parameter
parameter passing methods in pls
Parameter Passing Methods in PLs
  • PHP
    • very similar to C#
  • Perl
    • all actual parameters are implicitly placed in a predefined array named @_
type checking of parameters
Type Checking of Parameters
  • Very important for reliability
    • Which errors are caught by type checking?
  • FORTRAN 77 and original C
    • No type checking
  • Pascal, FORTRAN 90, Java, and Ada
    • Type checking is always done
  • ANSI C and C++, Lisp
    • User can avoid type checking
subprograms as parameters
Subprograms As Parameters
  • Are subprograms allowed as parameters?
    • if so, are types checked?
  • Early Pascal and FORTRAN 77
    • no
  • Later versions of Pascal and FORTRAN 90
    • yes
  • C and C++
    • pass pointers to functions
    • parameters can be type checked
  • Java, Ada, Perl
    • no
referencing environments
Referencing Environments
  • What is the correct referencing environment of a subprogram that is passed as a parameter?
  • Possibilities:
    • It is that of the subprogram that declared it
      • Deep binding
      • Most natural for static-scopedPLs
    • It is that of the subprogram that enacted it
      • Shallow binding
      • Most natural for dynamic-scopedPLs
    • It is that of the subprogram that passed it
      • Ad hoc binding (Has never been used)
referencing environments cont
Referencing Environments (cont.)

Example: function sub1() {

var x;

function sub2() {



function sub3() {

var x=3;

call sub4(sub2);


function sub4(subx) {

var x=4;

call subx();



call sub3;


  • What is the referencing environment of sub2 when it is called in sub4?
    • Shallow binding => sub2 <- sub4 <- sub3 <- sub1 [output = 4]
    • Deep binding => sub2 <- sub1 [output = 1]
    • Ad-hoc binding => sub3 local x [output = 3]
nested subprogram definitions
Nested Subprogram Definitions
  • Does the language allow them?
  • Are there limits on nesting depth?
  • How are non-local variables handled?
    • Static scope
    • Dynamic scope
design issues specific to functions
Design Issues Specific to Functions
  • Are side effects allowed?
    • Two-way parameters
      • Ada does not allow them
    • Non-local references
      • Allowed in all PLs
  • What types of return values are allowed?
return types of functions in pls
Return Types of Functions in PLs
  • FORTRAN, Pascal
    • only simple types
  • C
    • any type except functions and arrays
  • Ada
    • any type (but subprograms are not types)
  • C++ and Java
    • like C, but also allow classes to be returned
  • Common Lisp
    • any type, function, class, object, structure, closure, etc.
accessing non local environments
Accessing Non-local Environments
  • Non-local variables
    • variables that are visible but not declared inthe subprogram
  • Global variables
    • variables that are visible in all subprograms
nonlocal environments in pl
Nonlocal Environments in PL
    • The only way in pre-90 FORTRAN to access nonlocal variables
    • Can be used to share data or share storage
  • Static scoping
    • discussed already
  • External declarations - C
    • Subprograms are not nested
    • Globals are created by external declarations
      • they are simply defined outside any function
    • Access is by either implicit or explicit declaration
    • Declarations give types to externally defined variables
  • External modules - Ada
    • More in Chapter 11
  • 5. Dynamic Scope – Common Lisp
overloaded subprograms
Overloaded Subprograms
  • Overloaded subprogram
    • has the same name as another subprogram in the same referencing environment
  • C++, Java and Ada
    • have built-in subprogram overloading
    • users can write their own overloaded subprograms
generic subprograms
Generic Subprograms
  • A generic or polymorphicsubprogram
    • takes parameters of different types on different activations, or
    • executes different code on different activations
  • Overloaded subprograms offer
    • adhocpolymorphism
  • A subprogram where the type of a parameter is described by a type expression with a generic parameter
    • parametric polymorphism
generic subprograms in ada
Generic Subprograms in Ada
  • Ada
    • types, subscript ranges, constant values, etc., can be generic in subprograms, packages
    • e.g.


type element is private;

type vector is array (INTEGER range <>)

of element;

procedure Generic_Sort (list: in out vector);

generic subprograms in ada cont
Generic Subprograms in Ada (cont.)

procedure Generic_Sort (list : in out vector)

is temp: element;


for i in list'FIRST.. i'PRED(list'LAST) loop

for j in i'SUCC(i)..list'LAST loop

if list(i) > list(j) then

temp := list(i);

list(i) := list(j);

list(j) := temp;

end if;

end loop; -- for j

end loop; --for i

End Generic_Sort

procedure Integer_Sort is new Generic_Sort

(element => INTEGER; vector => INTEGER_ARRAY);

generic subprograms parameters in ada
Generic Subprograms Parameters in Ada
  • Ada generics can be used for parameters that are subprograms
    • Note: the generic part is a subprogram
  • Example:

generic with function fun(x: FLOAT) return FLOAT;

procedure integrate

(from: in FLOAT; to: in FLOAT; result: out FLOAT) is




x := fun(from);



integrate_fun is new integrate(fun => my_fun);

parametric polymorphism in c
Parametric Polymorphism in C++
  • C++
    • Template functions
    • e.g.

template <class Type>

Type max(Type first, Type second) {

return first > second ? first : second;


c template functions
C++ Template Functions
  • Template functions are instantiated implicitly when
    • the function is named in a call, or
    • its address is taken with the & operator
  • Example:

template <class Type>

void generic_sort(Type list[], int len) {

int i, j;

Type temp;

for (i = 0; i < len - 2; i++)

for (j = i + 1; j < len - 1; j++) {

if (list[i] > list[j]) {

temp = list [i]; list[i] = list[j]; list[j] = temp;

} //** end if

} //** end for j

} //** end for i

} //** end of generic_sort

float number_list[100];

generic_sort(number_list, 100); // Implicit instantiation

generics in java
Generics in Java
  • Java provides generic types
    • Syntax:
      • class_name<generic_class {, generic_class}*>

e.g.: class MyList<Element> extends ArrayList<Element> {…}

e.g.: class MyMap<Key,Value> extends HashMap<Key,Value> {…}

    • Types substituted when used:

e.g.: MyList<String> courses = new MyList<String>();

e.g.: MyMap<String,String> table = new MyMap<String,String>();

  • Type-checking works!

courses.add("ics313"); // ok

courses.add(313); // incorrect, 313 is not String

  • No casts needed!

String course = courses.get(0); //(String)courses.get(0)??

generics in java cont
Generics in Java (cont.)
  • Generic types can be restricted to subclasses

class UrlList<Element extends URL> {…}

  • Generic types can be used in "for-each" clause

for (String course : courses) {

System.out.println (course.toUpperCase());


  • Generic types are used in standard libraries
    • Collections:
      • List, ArrayList, Map, Set
  • Primitive types can be substituted for generic types

class MyList<Element> extends ArrayList<Element> {…}

MyList<Integer> numbers = new MyList<Integer>()


int sum = 0;

for (int number : numbers) {sum += number;}

generics in java parameters return type
Generics in Java: Parameters, Return Type
  • Generic types can be used
    • as formal parameters

class MyList<Element> extends ArrayList<Element> {

int occurences(Element element) {

if (element.equals(this)) sum++;



    • even as return type

class MyList<Element> extends ArrayList<Element> {

Element[] toArray() {

Element[] array = new Element[this.size()];

return array;



generic methods in java
Generic Methods in Java
  • Method can be made depend on a generic type
    • Generic type precedes method's return type
    • Generic type can be used to
      • As the return type
      • To declare formal parameters
      • To declare local variables
    • E.g.

<T> T succ(T value, T [] array) {

T element = null;


return element;


    • Actual type is inferred from the call

Integer [] array = {1, 2, 3, 4, 5, 6};

int successor = succ(3, array);