Parameters Chapter Eighteen Modern Programming Languages, 2nd ed. - - PowerPoint PPT Presentation

▶
parameters
SMART_READER_LITE
LIVE PREVIEW

Parameters Chapter Eighteen Modern Programming Languages, 2nd ed. - - PowerPoint PPT Presentation

Jul 16, 2023 168 likes •679 views

Parameters Chapter Eighteen Modern Programming Languages, 2nd ed. 1 Parameter Passing formal parameters int plus(int a, int b) { return a+b; method body } int x = plus(1,2); actual parameters method call How are parameters passed?

slide-1
SLIDE 1

Parameters

Chapter Eighteen Modern Programming Languages, 2nd ed. 1

slide-2
SLIDE 2

Parameter Passing

 How are parameters passed?  Looks simple enough…  We will see seven techniques

Chapter Eighteen Modern Programming Languages, 2nd ed. 2

int plus(int a, int b) { return a+b; } int x = plus(1,2); formal parameters method body method call actual parameters

slide-3
SLIDE 3

Outline

 18.2 Parameter correspondence  Implementation techniques

– 18.3 By value – 18.4 By result – 18.5 By value-result – 18.6 By reference – 18.7 By macro expansion – 18.8 By name – 18.9 By need

 18.10 Specification issues

Chapter Eighteen Modern Programming Languages, 2nd ed. 3

slide-4
SLIDE 4

Parameter Correspondence

 A preliminary question: how does the

language match up parameters?

 That is, which formal parameters go with

which actual parameters?

 Most common case: positional parameters

– Correspondence determined by positions – nth formal parameter matched with nth actual

Chapter Eighteen Modern Programming Languages, 2nd ed. 4

slide-5
SLIDE 5

Keyword Parameters

 Correspondence can be determined by

matching parameter names

 Ada:

DIVIDE(DIVIDEND => X, DIVISOR => Y);

 Matches actual parameter X to formal

parameter DIVIDEND, and Y to DIVISOR

 Parameter order is irrelevant here

Chapter Eighteen Modern Programming Languages, 2nd ed. 5

slide-6
SLIDE 6

Mixed Keyword And Positional

 Most languages that support keyword

parameters allow both: Ada, Fortran, Dylan, Python

 The first parameters in a list can be

positional, and the remainder can be keyword parameters

Chapter Eighteen Modern Programming Languages, 2nd ed. 6

slide-7
SLIDE 7

Optional Parameters

 Optional, with default values: formal

parameter list includes default values to be used if the corresponding actual is missing

 This gives a very short way of writing

certain kinds of overloaded function definitions

Chapter Eighteen Modern Programming Languages, 2nd ed. 7

slide-8
SLIDE 8

Example: C++

Chapter Eighteen Modern Programming Languages, 2nd ed. 8

int f(int a=1, int b=2, int c=3) { body } int f() {f(1,2,3);} int f(int a) {f(a,2,3);} int f(int a, int b) {f(a,b,3);} int f(int a, int b, int c) { body }

slide-9
SLIDE 9

Unlimited Parameter Lists

 Some languages allow actual parameter lists

  • f unbounded length: C, C++, and scripting

languages like JavaScript, Python, and Perl

 Library routines must be used to access the

excess actual parameters

 A hole in static type systems, since the

types of the excess parameters cannot be checked at compile time

Chapter Eighteen Modern Programming Languages, 2nd ed. 9

int printf(char *format, ...) { body }

slide-10
SLIDE 10

Outline

 18.2 Parameter correspondence  Implementation techniques

– 18.3 By value – 18.4 By result – 18.5 By value-result – 18.6 By reference – 18.7 By macro expansion – 18.8 By name – 18.9 By need

 18.10 Specification issues

Chapter Eighteen Modern Programming Languages, 2nd ed. 10

slide-11
SLIDE 11

By Value

 Simplest method  Widely used  The only method in real Java

Chapter Eighteen Modern Programming Languages, 2nd ed. 11

For by-value parameter passing, the formal parameter is just like a local variable in the activation record of the called method, with one important difference: it is initialized using the value of the corresponding actual parameter, before the called method begins executing.

slide-12
SLIDE 12

Chapter Eighteen Modern Programming Languages, 2nd ed. 12

int plus(int a, int b) { a += b; return a; } void f() { int x = 3; int y = 4; int z = plus(x, y); }

When plus is starting

previous activation record return address x: 3 previous activation record result: ? return address a: 3 current activation record b: 4 y: 4 z: ?

slide-13
SLIDE 13

Changes Visible To The Caller

 When parameters are passed by value,

changes to a formal do not affect the actual

 But it is still possible for the called method

to make changes that are visible to the caller

 The value of the parameter could be a

pointer (in Java, a reference)

 Then the actual cannot be changed, but the

  • bject referred to by the actual can be

Chapter Eighteen Modern Programming Languages, 2nd ed. 13

slide-14
SLIDE 14

Chapter Eighteen Modern Programming Languages, 2nd ed. 14

void f() { ConsCell x = new ConsCell(0,null); alter(3,x); } void alter(int newHead, ConsCell c) { c.setHead(newHead); c = null; }

When alter is starting

previous activation record return address x: previous activation record return address newHead: 3 current activation record c:

head: 0 tail: null

slide-15
SLIDE 15

Chapter Eighteen Modern Programming Languages, 2nd ed. 15

void f() { ConsCell x = new ConsCell(0,null); alter(3,x); } void alter(int newHead, ConsCell c) { c.setHead(newHead); c = null; }

When alter is finishing

previous activation record return address x: previous activation record return address newHead: 3 current activation record c: null

head: 3 tail: null

slide-16
SLIDE 16

By Result

 Also called copy-out  Actual must have an lvalue  Introduced in Algol 68; sometimes used for

Ada

Chapter Eighteen Modern Programming Languages, 2nd ed. 16

For by-result parameter passing, the formal parameter is just like a local variable in the activation record of the called method—it is uninitialized. After the called method finished executing, the final value of the formal parameter is assigned to the corresponding actual parameter.

slide-17
SLIDE 17

Chapter Eighteen Modern Programming Languages, 2nd ed. 17

void plus(int a, int b, by-result int c) { c = a+b; } void f() { int x = 3; int y = 4; int z; plus(x, y, z); }

When plus is starting

previous activation record return address x: 3 previous activation record return address a: 3 current activation record b: 4 y: 4 z: ? c: ?

slide-18
SLIDE 18

Chapter Eighteen Modern Programming Languages, 2nd ed. 18

void plus(int a, int b, by-result int c) { c = a+b; } void f() { int x = 3; int y = 4; int z; plus(x, y, z); }

When plus is ready to return

previous activation record return address x: 3 previous activation record return address a: 3 current activation record b: 4 y: 4 z: ? c: 7

slide-19
SLIDE 19

Chapter Eighteen Modern Programming Languages, 2nd ed. 19

void plus(int a, int b, by-result int c) { c = a+b; } void f() { int x = 3; int y = 4; int z; plus(x, y, z); }

When plus has returned

previous activation record return address x: 3 previous activation record return address a: 3 current activation record b: 4 y: 4 z: 7 c: 7

slide-20
SLIDE 20

By Value-Result

 Also called copy-in/copy-out  Actual must have an lvalue

Chapter Eighteen Modern Programming Languages, 2nd ed. 20

For passing parameters by value-result, the formal parameter is just like a local variable in the activation record of the called method. It is initialized using the value of the corresponding actual parameter, before the called method begins executing. Then, after the called method finishes executing, the final value of the formal parameter is assigned to the actual parameter.

slide-21
SLIDE 21

Chapter Eighteen Modern Programming Languages, 2nd ed. 21

void plus(int a, by-value-result int b) { b += a; } void f() { int x = 3; plus(4, x); }

When plus is starting

previous activation record return address x: 3 previous activation record return address a: 4 current activation record b: 3

slide-22
SLIDE 22

Chapter Eighteen Modern Programming Languages, 2nd ed. 22

void plus(int a, by-value-result int b) { b += a; } void f() { int x = 3; plus(4, x); }

When plus is ready to return

previous activation record return address x: 3 previous activation record return address a: 4 current activation record b: 7

slide-23
SLIDE 23

Chapter Eighteen Modern Programming Languages, 2nd ed. 23

void plus(int a, by-value-result int b) { b += a; } void f() { int x = 3; plus(4, x); }

When plus has returned

previous activation record return address x: 7 previous activation record return address a: 4 current activation record b: 7

slide-24
SLIDE 24

By Reference

 One of the earliest methods: Fortran  Most efficient for large objects  Still frequently used

Chapter Eighteen Modern Programming Languages, 2nd ed. 24

For passing parameters by reference, the lvalue of the actual parameter is computed before the called method

  • executes. Inside the called method, that lvalue is used

as the lvalue of the corresponding formal parameter. In effect, the formal parameter is an alias for the actual parameter—another name for the same memory location.

slide-25
SLIDE 25

Chapter Eighteen Modern Programming Languages, 2nd ed. 25

void plus(int a, by-reference int b) { b += a; } void f() { int x = 3; plus(4, x); }

When plus is starting

previous activation record return address x: 3 previous activation record return address a: 4 current activation record b:

slide-26
SLIDE 26

Chapter Eighteen Modern Programming Languages, 2nd ed. 26

void plus(int a, by-reference int b) { b += a; } void f() { int x = 3; plus(4, x); }

When plus has made the assignment

previous activation record return address x: 7 previous activation record return address a: 4 current activation record b:

slide-27
SLIDE 27

Implementing Reference

Chapter Eighteen Modern Programming Languages, 2nd ed. 27

void plus(int a, int *b) { *b += a; } void f() { int x = 3; plus(4, &x); } void plus(int a, by-reference int b) { b += a; } void f() { int x = 3; plus(4, x); }

C implementation By-reference = address by value Previous example

slide-28
SLIDE 28

Aliasing

 When two expressions have the same

lvalue, they are aliases of each other

 There are obvious cases:  Passing by reference leads to less obvious

cases…

Chapter Eighteen Modern Programming Languages, 2nd ed. 28

ConsCell x = new ConsCell(0,null); ConsCell y = x; A[i]=A[j]+A[k];

slide-29
SLIDE 29

Example

Chapter Eighteen Modern Programming Languages, 2nd ed. 29

void sigsum(by-reference int n, by-reference int ans) { ans = 0; int i = 1; while (i <= n) ans += i++; } int f() { int x,y; x = 10; sigsum(x,y); return y; } int g() { int x; x = 10; sigsum(x,x); return x; }

slide-30
SLIDE 30

Chapter Eighteen Modern Programming Languages, 2nd ed. 30

void sigsum(by-reference int n, by-reference int ans) { ans = 0; int i = 1; while (i <= n) ans += i++; } int g() { int x; x = 10; sigsum(x,x); return x; }

When sigsum is starting

previous activation record return address x: 10 previous activation record return address n: current activation record ans: i: ? result: ?

slide-31
SLIDE 31

By Macro Expansion

 Like C macros  Natural implementation: textual substitution

before compiling

Chapter Eighteen Modern Programming Languages, 2nd ed. 31

For passing parameters by macro expansion, the body

  • f the macro is evaluated in the caller’s context. Each

actual parameter is evaluated on every use of the corresponding formal parameter, in the context of that

  • ccurrence of that formal parameter (which is itself in

the caller’s context).

slide-32
SLIDE 32

Macro Expansions In C

 An extra step in the classical sequence  Macro expansion before compilation

Chapter Eighteen Modern Programming Languages, 2nd ed. 32

#define MIN(X,Y) ((X)<(Y)?(X):(Y)) a = MIN(b,c); a = ((b)<(c)?(b):(c))

source file: expanded source:

editor pre-processor compiler source file expanded source assembly- language file

slide-33
SLIDE 33

Preprocessing

 Replace each use of the macro with a copy

  • f the macro body, with actuals substituted

for formals

 An old technique, used in assemblers before

the days of high-level languages

 It has some odd effects…

Chapter Eighteen Modern Programming Languages, 2nd ed. 33

slide-34
SLIDE 34

Repeated Evaluation

 Each actual parameter is re-evaluated every

time it is used

Chapter Eighteen Modern Programming Languages, 2nd ed. 34

#define MIN(X,Y) ((X)<(Y)?(X):(Y)) a = MIN(b++,c++); a = ((b++)<(c++)?(b++):(c++))

source file: expanded source:

slide-35
SLIDE 35

Capture Example

Chapter Eighteen Modern Programming Languages, 2nd ed. 35

#define intswap(X,Y) {int temp=X; X=Y; Y=temp;} int main() { int temp=1, b=2; intswap(temp,b); printf("%d, %d\n", temp, b); } int main() { int temp=1, b=2; {int temp= temp ; temp = b ; b =temp;} ; printf("%d, %d\n", temp, b); }

source file: expanded source:

slide-36
SLIDE 36

Capture

 In a program fragment, any occurrence of a

variable that is not statically bound is free

 When a fragment is moved to a different

context, its free variables can become bound

 This phenomenon is called capture:

– Free variables in the actuals can be captured by

definitions in the macro body

– Also, free variables in the macro body can be

captured by definitions in the caller

Chapter Eighteen Modern Programming Languages, 2nd ed. 36

slide-37
SLIDE 37

By Name

 Like macro expansion without capture  Algol 60 and others  Now unpopular

Chapter Eighteen Modern Programming Languages, 2nd ed. 37

For passing parameters by name, each actual parameter is evaluated in the caller’s context, on every use of the corresponding formal parameter.

slide-38
SLIDE 38

Implementing By-Name

 The actual parameter is treated like a little

anonymous function

 Whenever the called method needs the

value of the formal (either rvalue or lvalue) it calls the function to get it

 The function must be passed with its nesting

link, so it can be evaluated in the caller’s context

Chapter Eighteen Modern Programming Languages, 2nd ed. 38

slide-39
SLIDE 39

Chapter Eighteen Modern Programming Languages, 2nd ed. 39

void f(by-name int a, by-name int b) { b=5; b=a; } int g() { int i = 3; f(i+1,i); return i; }

When f is starting

i

previous activation record return address i: 3 previous activation record return address current activation record a: b: result: ?

i+1

slide-40
SLIDE 40

Comparison

 Like macro expansion, by-name parameters

are re-evaluated every time they are used

 (Can be useful, but more often this is

merely wasteful)

 Unlike macro expansion, there is no

possibility of capture

Chapter Eighteen Modern Programming Languages, 2nd ed. 40

slide-41
SLIDE 41

By Need

 Used in lazy functional languages (Haskell)  Avoids wasteful recomputations of by-name

Chapter Eighteen Modern Programming Languages, 2nd ed. 41

For passing parameters by need, each actual parameter is evaluated in the caller’s context, on the first use of the corresponding formal parameter. The value of the actual parameter is then cached, so that subsequent uses of the corresponding formal parameter do not cause reevaluation.

slide-42
SLIDE 42

Chapter Eighteen Modern Programming Languages, 2nd ed. 42

void f(by-need int a, by-need int b) { b=a; b=a; } void g() { int i = 3; f(i+1,i); return i; }

When f is starting

i

previous activation record return address i: 3 previous activation record return address current activation record a: b: result: ?

i+1

slide-43
SLIDE 43

Laziness

Chapter Eighteen Modern Programming Languages, 2nd ed. 43

boolean andand(by-need boolean a, by-need boolean b) { if (!a) return false; else return b; } boolean g() { while (true) { } return true; } void f() { andand(false,g()); } Here, andand is short-circuiting, like ML’s andalso and Java’s &&

  • perators.

The method f will terminate. Same behavior for by-name and macro expansion.

slide-44
SLIDE 44

Outline

 18.2 Parameter correspondence  Implementation techniques

– 18.3 By value – 18.4 By result – 18.5 By value-result – 18.6 By reference – 18.7 By macro expansion – 18.8 By name – 18.9 By need

 18.10 Specification issues

Chapter Eighteen Modern Programming Languages, 2nd ed. 44

slide-45
SLIDE 45

Specification Issues

 Are these just implementation techniques,

  • r part of the language specification?

 Depends on the language:

– Without side-effects, parameter-passing

technique may be undetectable by the programmer

– Even with side effects, some languages specify

the parameter passing technique only partially

Chapter Eighteen Modern Programming Languages, 2nd ed. 45

slide-46
SLIDE 46

Without Side Effects

 Big question: are parameters always

evaluated (eager evaluation), or only if they are really needed (lazy evaluation)?

 Cost model may also be used by the

programmer (more in Chapter 21):

– Is re-evaluation of a formal expensive? – Does parameter-passing take time proportional

to the size of the object?

Chapter Eighteen Modern Programming Languages, 2nd ed. 46

slide-47
SLIDE 47

With Side Effects

 A program can detect which parameter-

passing technique is being used by the language system

 But it may be an implementation detail that

programs are not supposed to depend on—it may not be part of the specification of the language

 Case in point: Ada

Chapter Eighteen Modern Programming Languages, 2nd ed. 47

slide-48
SLIDE 48

Ada Modes

 Three parameter-passing modes:

– in: these can be read in the called method, but

not assigned—like constants

– out: these must be assigned and cannot be read – in out: may be read and/or assigned

 Ada specification intentionally leaves some

flexibility for implementations

Chapter Eighteen Modern Programming Languages, 2nd ed. 48

slide-49
SLIDE 49

Ada Implementations

 Copying is specified for scalar values:

– in = value, out = result, in out = value/

result

 Aggregates like arrays and records may be

passed by reference instead

 Any program that can detect the difference

(like some of our earlier examples) is not a legal Ada program

Chapter Eighteen Modern Programming Languages, 2nd ed. 49

slide-50
SLIDE 50

Conclusion

 Today:

– How to match formals with actuals – Seven different parameter-passing techniques – Ideas about where to draw the line between

language definition and implementation detail

 These are not the only schemes that have

been tried, just some of the most common

 The CS corollary of Murphy’s Law:

Chapter Eighteen Modern Programming Languages, 2nd ed. 50

Inside every little problem there is a big problem waiting to get out