1. Advanced Programming Parameter Passing Giuseppe Attardi Università di Pisa

2. Parameter Passing

3. Call by value Call by value Call by reference Call by reference Call by result, value/result Call by result, value/result C++ references C++ references Closures as parameters Closures as parameters Call by name Call by name Label parameters Label parameters Variable number of arguments Variable number of arguments Function returns Function returns

4. Terminology Expressions evaluate to R-values Variables and components of variables of structured types also have an L-value, that is, an address where their R-value is stored The assignment statement requires an L-value on the left-hand side (L stands for “left”) and an R-value on the right-hand side (R stands for “right”)

5. int x = 3; x = x; int v[40]; v[3] = v[3] (x == 3) = 3 = int foo(); foo = …. point.x = 12;

6. Value model, reference model b = 2; c = b; b = b +1; a = b + c; 5 2 2 a b c a b c Value modelReference model 6 3 2 3

7. Example class Point { int x, y; } Point p = Point(3, 4); Point p2 = p; p.x = 5; p2.x ? foo(p); int i = 3; Integer I = new Integer(3);

8. C void foo (int* x) { *x = 3; } struct Point { int x, y}; void bar(Point* p) { p->x = 3; } Point p; p.x = 5; Point* p2 = &p; bar(p2);

9. Reference model In language using reference model, every variable is a L-value In language using reference model, every variable is a L-value When it appears in a R-value context, it must be dereferenced When it appears in a R-value context, it must be dereferenced Usually dereference is implicit Usually dereference is implicit Examples: Examples: –Algol68, Lisp, ML, Haskell, SmallTalk Java: mixed (value for built-in types) Java: mixed (value for built-in types)

10. Call by value The value of the R-value of the actual parameter is copied into the formal parameter at invocation The value of the R-value of the actual parameter is copied into the formal parameter at invocation

11. Call by result The value of the formal parameter is copied into the actual parameter (which must have an L-value) at procedure return. The value of the formal parameter is copied into the actual parameter (which must have an L-value) at procedure return.

12. Call by value/result The parameter is treated as in value mode during invocation and as in result mode during return. The parameter is treated as in value mode during invocation and as in result mode during return.

13. foo (inout x) { … x …} foo1 (ref x) { … x = x + 1; … } foo1(v[3]); s = “asdasd”; foo1(s); // OK foo1(“asdasd”); // KO foo1(3); // KO int y = 7; foo1(y);y?

14. foo2 (Point ref q) { q = new Point(); } Point p = new Point(3,4); Point prev = p; foo2(ref p); p == prev?

15. void foo (ref int x) { x = x + 3; x = x/0; } int z = 2; foo(z);

16. Call by reference The L-value of the formal parameter is set to the L-value of the actual parameter. The L-value of the formal parameter is set to the L-value of the actual parameter. The address of the formal parameter is the same as the address of the actual parameter. Any assignment to the formal parameter immediately affects the actual parameter. The address of the formal parameter is the same as the address of the actual parameter. Any assignment to the formal parameter immediately affects the actual parameter.

17. Note // C# void foo(int ref x) { x += 1; } // C++ void foo(int& x) { x += 1; } int a[3]; a[0] = 0; foo(ref a[0]);// C# foo(a[0]);// C++ foo(p);

18. C++ Reference Datatype C++ provides a Reference dataype, built from other types C++ provides a Reference dataype, built from other types If T is a type T& is a new type called “reference to T” If T is a type T& is a new type called “reference to T” One should avoid the confusion between the general concept of reference and a Reference Type One should avoid the confusion between the general concept of reference and a Reference Type Also avoid the confusion with the notion of Reference types in Java and C# Also avoid the confusion with the notion of Reference types in Java and C# Reference Types are not pointers, even though they are implemented through pointers and hence accessing a reference type may involve an implicit dereference operation Reference Types are not pointers, even though they are implemented through pointers and hence accessing a reference type may involve an implicit dereference operation Using Reference Types in parameters even though they are still passed by value. Using Reference Types in parameters even though they are still passed by value.

19. Reference/Value Types In programming language theory, a reference type is a data type that can only be accessed by references In programming language theory, a reference type is a data type that can only be accessed by referencesdata typereferencesdata typereferences Objects of a reference type are always dynamically allocated Objects of a reference type are always dynamically allocateddynamically allocateddynamically allocated value type objects instead can be manipulated directly and are copied when moved (assignment, parameter passing or function return) value type objects instead can be manipulated directly and are copied when moved (assignment, parameter passing or function return) value type value type

20. C++ Reference Type Example void foo(int& x) { x = x + 1; } int y = 7; foo(y); y ? foo(3);// only feasible if x was // declared as const int&

21. Call by name Every use of the formal parameter causes the actual parameter to be freshly evaluated in the referencing environment of the invocation point. If the formal parameter’s L-value is needed (for example, the parameter appears on the left-hand side of an assignment), the actual parameter’s L-value must be freshly evaluated. If the formal parameter’s Rvalue is needed, the actual parameter’s R-value must be freshly evaluated.

22. Call by name: example int sum(name int expr, name int j, int size) { int tot = 0; int tot = 0; for (; j < size; j++) for (; j < size; j++) tot += expr; return tot; return tot;} sum(A[i], i, n); /* sum of vector elements */

23. { int i; int[] A; &int thunk() { return &A[i]; } sum(thunk, i, n); }

24. Call by macro Every use of the formal parameter causes the text of the actual parameter to be freshly evaluated in the referencing environment of the use point. Every use of the formal parameter causes the text of the actual parameter to be freshly evaluated in the referencing environment of the use point.

25. #DEFINE foo(x) x + x foo(read()) read() + read() inline int foo(int x) { return x + x; } int foo(int& x, int &y) { x++; y++; return x + y;} Foo(a, a);

26. Parameter passing modes ImplementationOperations Change to actual? Alias? ValueValueRWNono In, const Value, reference RONoMaybe Out (C#, Ada) Value, reference WOYesMaybe Value/resultValueRWYesNo Var, ref ReferenceRWYesYes Sharing Value, reference RWYesMaybe In out Value, reference RWYesMaybe NameClosureRWYesyes

27. Esercizio swap(x, y) using just call-by-value swap(x, y) using just call-by-value void swap(int x, int y) { int temp; int temp; temp = x; temp = x; x = y; x = y; y = temp; y = temp;}; Does not work.

28. swap(x, y) using just call-by-name swap(x, y) using just call-by-name int b[10]; swap(i, b[i]); void swap(name int x, name int y) { int temp; int temp; temp = x; temp = x; x = y; x = y; y = temp; y = temp;};

29. Note on List l = new List(); Student s = new Student(); l.add(s); float pi = 3.14; l.add(pi); (new Integer(314)).toString(); s.toString();

30. Note int a[] = new int[3]; int b[] = new int[5]; swap(a, b); a swap(i, a[i]); int temp; temp = x; x = y; y = temp; a=3, b=5; a=5, b=5; a=5, b=3; void swap(inout int x, inout int y) { int temp; int temp; temp = x; temp = x; x = y; x = y; y = temp; y = temp;};

31. Exercise swap(x, y) using just call-by-name swap(x, y) using just call-by-name swap(name x, name y) => { } Does it work?

32. Call by name Counter example: swap(i, A[i]) (i=3, A[3] = 4) => (i=4, A[4] = 4, A[3] unchanged)

33. Call by value/result swap(i, A[i]) works even in case (i=2, A[2]= 99) swap(i, A[i]) works even in case (i=2, A[2]= 99)

34. Call by value Copies argument Copies argument Special cases: Special cases: –array –struct typedef struct { int x, y} Pair; Pair q; zed(q); Pair foo() { Pair p; return p; } Pair p = foo(); stack.push_back(Pair(2,3)); int [200000] v; bar(v); std::string s; bad(s);

35. int* foo() { int v[100]; return v; }

36. Closures First Class function objects

37. Downward Closure in Pascal

38. Lexical Environment of Functions Because of nested lexical scope, even passing functions in Pascal requires passing the enclosing lexical environment Because of nested lexical scope, even passing functions in Pascal requires passing the enclosing lexical environment

40. Closure in Python def makeInc(x): def inc(y): return y + x return inc inc3 = makeInc(3) inc10 = makeInc(10) inc3(5) # returns 8 inc10(5) # returns 15

42. Closure as Classes def makePair(x, y): def get(arg): if arg == ‘x’: return x if arg == ‘x’: return x elif arg == ‘y’ elif arg == ‘y’ return y return get p = makePair(3, 5) p(‘x’) -> 3 P(‘y’) -> 5