Programming languages and design lecture 7 subroutines and control abstraction
This presentation is the property of its rightful owner.
Sponsored Links
1 / 21

Programming Languages and Design Lecture 7 Subroutines and Control Abstraction PowerPoint PPT Presentation


  • 85 Views
  • Uploaded on
  • Presentation posted in: General

Programming Languages and Design Lecture 7 Subroutines and Control Abstraction. Instructor: Li Ma Department of Computer Science Texas Southern University, Houston. April, 2008. Review of Previous Lectures. Introduction to programming languages

Download Presentation

Programming Languages and Design Lecture 7 Subroutines and Control Abstraction

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


Programming languages and design lecture 7 subroutines and control abstraction

Programming Languages and DesignLecture 7Subroutines and Control Abstraction

Instructor: Li Ma

Department of Computer Science

Texas Southern University, Houston

April, 2008


Review of previous lectures

Review of Previous Lectures

  • Introduction to programming languages

  • Syntax specifications of programming languages

  • Semantic specifications of programming languages

  • Functional Programming

    • Scheme

  • Object-Oriented Programming

    • C++ & Java

  • Names, binding, and scopes

    • Static vs. Dynamic


Today s lecture

Today’s Lecture

  • Parameter passing mechanisms

    • By constant-value

    • By result

    • By value-result

    • By reference

    • By name

  • References

    • “Foundations of Programming Languages: Design and Implementation”, S. H. Roosta, Chapter 3 (§3.2)

    • “Programming Language Pragmatics”, Michael Scott, Chapter 8 (§8.1 – 8.3)


Name is abstraction

Name is Abstraction

  • Names enable programmers to refer to variables, constants, operations, and types using identifier names

  • Names are control abstractions and data abstractions for program fragments and data structures

    • Data abstraction:

      • Object-oriented classes hide data representation details behind a set of operations

    • Control abstraction:

      • Subroutines (procedures and functions) allow programmers to focus on manageable subset of program text

      • Subroutine interface hides implementation details


Mechanisms for processing control abstraction

Mechanisms for Processing Control Abstraction

  • Single entry (except FORTRAN, PL/I)

  • Caller is suspended

  • Control returns to caller


Subroutine design issues

Subroutine Design Issues

  • Syntax, type checking

  • Parameter passing mechanisms

  • Static or dynamic allocation of locals

  • Static or dynamic scope

  • Environment of parameter functions

  • Overloading

  • Generics

  • Separate compilation


Parameters in subroutine

Parameters in Subroutine

  • Parameter transmission is the major alternative method for sharing data objects among subroutines

  • Formal parameter, or parameter

    • Local data object within a subprogram

    • Specification of the parameter in the invoked subprogram

  • Actual parameter, or argument

    • Specification of the parameter in the invoking subprogram

    • A data object shared with the caller program


Call by value

Call by Value

  • Allocate memory for parameter

  • Initialize parameter with the argument’s value

  • Call procedure

  • Nothing happens on return

  • Used in C, C++, Pascal, Lisp, ML, etc.

  • Accesses are usually more efficient with this method

  • But additional storage is required for the formal parameters in the called subprogram


Call by value example

Call-by-Value Example

int a = 1;

void foo (int x) {

// a and x have same value,

// changes to a or x don’t

// affect each other

}

// argument can be expression

foo (a + a);

// no modifications to a


Call by result

Call by Result

  • Argument must be variable

  • Allocate memory for parameter

  • Don’t initialize parameter

  • Call Procedure

  • . . . (within here, parameter will get a value)

  • Copy parameter into argument variable

  • Return from procedure

  • Additional storage is required for the formal parameters in the called subprogram


Call by result example

Call-by-Result Example

int a = 2;

void foo (int x) {

// x is not initialized,

// changes to a or x don’t

// affect each other

}

// argument must be variable

foo (a);

// a will be modified


Call by value result

Call by Value-Result

  • Copy-In-Copy-Out, or passing by copy

  • Combination of the first two

  • Copy argument value on call

  • Copy result on return

  • Used by Ada for parameters of primitive type in in-out mode

  • Additional storage is required for the formal parameters and time for coping values


Call by value result example

Call-by-Value-Result Example

int a = 3;

void foo (int x) {

// a and x have same value

// changes to a or x don’t

// affect each other

}

// argument must be variable

foo (a);

// a might be modified


Call by reference

Call by Reference

  • A pointer to the memory location of the data object is made available to the called subprogram

    • Evaluate argument to get the location of the variable

  • Call procedure

  • Nothing happens on return

  • Used by FORTRAN before 1977, Pascal var parameter

  • Passing process is efficient in both time and space

  • But access to the formal parameter is slower due to one more level of indirect addressing


Call by reference example

Call-by-Reference Example

int a = 4;

void foo (int x) {

// a and x reference same location

// changes to a and x

// affect each other

}

// argument can be an expression

foo (a);

// a might be modified


Call by name

Call by Name

  • Don’t evaluate argument

  • Create closure to evaluate argument

  • Call procedure

  • Evaluate argument by calling parameter closure

  • Nothing happens on return

  • Used by ALGOL-60, Simula-67

  • Similar to macro expansion (e.g, TeX)


Call by name example

Call-by-Name Example

int a = 5;

void foo (int x) {

// x is a function

// to get value of argument,

// evaluate x() when value is needed

}

// argument can be an expression

foo (a + a);

// no modifications to a


Languages comparison in parameter passing

Languages Comparison in Parameter Passing

  • In Pascal, parameters are passed by value

    • The key word var is needed if passing by reference

  • Fortran passes all parameters by reference

    • If the parameter is not an l-value (it is an expression), then the compiler will create a temporary variable to hold the value, and pass this variable by reference

  • In Java, parameters of primitive types are passed by value; Object parameters are passed by sharing

    • Choose by value or by reference according to the argument (implemented as value or address)


Languages comparison in parameter passing cont

Languages Comparison in Parameter Passing (cont’)

  • Parameters in C are always passed by value, it must pass the address of variable explicitly

    int v1, v2;

    void swap (int *a, int *b) { int t=*a; *a=*b; *b=t; }

    swap (&v1, &v2);

  • C++ introduces an explicit notion of a reference

    void swap (int &a, int &b) { int t=a; a=b; b=t; }


Choose passing parameter method

Choose Passing Parameter Method

  • In a language that provides both value and reference parameters (Pascal, Modula), it needs rules to make decision

  • Concern about the efficiency and safety

    • If need to change the value of an argument – call by reference – efficient

    • If do not want to change the value of the argument – call by value – safe

  • Concern about the potential cost

    • Copying the large value from actuals to formals is potentially time-consuming

    • Accessing a parameter that is passed by reference requires an extra level of indirection


Choose passing parameter method cont

Choose Passing Parameter Method (cont’)

  • To combine the efficiency of reference parameters and the safety of value parameters

    • Modula-3 uses READONLY parameter mode

      • For small parameters, pass a value

      • For large parameters, pass an address

    • C uses const parameter

      void append_to_log (const huge_record *r) { … }

      append_to_log (&my_record);

      • const applies to the record to which r points

      • The caller passes the address of its record explicitly, the callee will not change the record’s content


  • Login