CSC 347 - Concepts of Programming Languages

Argument Passing

Instructor: Stefan Mitsch

Learning Objectives

How should arguments to functions be passed in?

• Interpret call-by-value and call-by-reference function calls

Argument Passing

• What are x, y, "hello", and 10 below:

  def f (x:String, y:Int) = x * y
  f ("hello", 10)
  

• x, y: formal parameters (or parameters)
• "hello", 10: actual parameters (or arguments)

Argument Passing

• What does a call to f print?

  def g (y:Int) : Int =
    y = y + 1
  end g
  def f () =
    var x = 1
    g (x)
    println (x)
  end f
  

• Prints 1 because Scala uses call-by-value

Call-By-Value vs. Call-By-Reference

Example

def g(y:Int) : Int =
  y = y + 1
end g
def f() =
  var x = 1
  g(x)
  println(x)
end f

CBR and Temporaries

• Can temporary values be passed as l-values?

• g(x+1) is not obviously legitimate in CBR
• Some languages reject it, some allow it
• Perl allows it

Call-By-Reference: Perl

• Perl uses CBR

sub g { 
    $_[0] = $_[0] + 1;
}
sub f {
    my $x = 1;
    g ($x);
    print ("x = $x\n");
}
f ();

$ perl ./cbr.pl 
x = 2

Call-By-Reference: Perl

• Perl allows temporaries!

sub g { 
    $_[0] = $_[0] + 1;
}
sub f {
    my $x = 1;
    g ($x + 1);
    print ("x = $x\n");
}
f ();

$ perl ./cbr.pl 
x = 1

Call-By-Reference: Perl

• Simulate CBV by creating copies explicitly

sub g { 
    my ($y) = @_;
    $y = $y + 1;
}
sub f {
    my $x = 1;
    g ($x);
    print ("x = $x\n");
}
f ();
# x=1

Call-By-Value: C

• Simulate CBR in C by explicitly passing, receiving, accessing a pointer

void g (int *p) {
  *p = *p + 1;
}
int main () {
  int x = 1;
  g (&x);
  printf ("x = %d\n", x);
  return 0;
}
// x=2

Call-By-Reference: C++

• C++ reference type int& (unlike int*, creates references implicitly)

void g(int& y) {
  y = y + 1;
}
int main() {
  int x = 1;
  g(x);
  // x==2
  cout << "x = " << x << endl;
  return 0;
}

• What makes this design error-prone?

Call-By-Reference: C++

• In C++, at caller CBR is indistinguishable from CBV

void g(int  y) { // vs. void g(int& y)
  y = y + 1;
}
int main() {
  int x = 1;
  g(x);
  // x==1 vs. x==2 when void g(int& y)
  cout << "x = " << x << endl;
  return 0;
}

• Small change in function signature, large effect at caller

Call-By-Reference: C#

• C# has reference parameters ref int

class Test {
  static void g (ref int y) {
    y = y + 1;
  }
  static void Main () {
    int x = 1;
    g (ref x);
    // x == 2
    Console.WriteLine("{0}", x);
  }
}

• Unlike int& must also be used by caller

Call-By-Reference: C++

• Passing a non-lvalue

void g(int& y) {
  y = y + 1;
}
int main() {
  int x = 1;
  g(x + 1);
  cout << "x = " << x << endl;
  return 0;
}

$ g++ -o reference reference.cpp 
reference.cpp: In function ‘int main()’:
referencs.cpp:11:8: error: invalid initialization of non-const
  reference of type ‘int&’ from an rvalue of type ‘int’
   g (x + 1);
        ^
references.cpp:5:6: error: in passing argument 1 of ‘void g(int&)’
 void g (int& y) {
      ^

Call-By-Value: Java

• Java has only a restricted form of pointers, called references
  • must point to heap-allocated objects
  • cannot point to stack-allocated data
  • cannot point to primitive types

• Java references cannot be forged
  • not from integers via casting
  • not from other references via pointer arithmetic
• Objects only accessed via references
  • unlike C++
  • Java has no address-of & operator

Call-By-Value: Java

• Simulate CBR In Java: heap-allocated object with field of intended argument type
• Pass a reference to the object instance by value

class IntRef { int n; }
public class Ref {
  static void g(IntRef r) { r.n = r.n + 1; }
  public static void main(String[] args) {
    IntRef s = new IntRef (); s.n = 1;
    g(s);
    // s.n == 2
    System.out.println (s.n);
  }
}

Call-By-Value: Scala

def f(x: Double) : Double = 
  val x1 = x
  val x2 = x
  x1 - x2
end f
println("f= " + f (Math.random())) // prints 0 (difference of same random Double)

Call-By-Value: Scala

• Scala allows functions as parameters
• A function that takes no arguments can be seen as a delayed value, also called a thunk

def g(x: () => Double) : Double = 
  val x1 = x()
  val x2 = x()
  x1 - x2
end g
println ("g= " + g (() => Math.random())) // prints difference of 2 random doubles

Call-By-Name: Scala

• Scala has a special syntax for using thunks as parameters
• Call-by-name parameters are non-strict

def h(x: => Double) : Double = 
  val x1 = x
  val x2 = x
  x1 - x2
end h
println ("h= " + h (Math.random())) // prints difference of 2 random doubles

Call-By-Name: Scala

• Curried call-by-name functions create new control constructs

  def myWhile (cond: => Boolean) (body: => Unit) : Unit = 
    if (cond)
      body
      myWhile (cond) (body)
  end myWhile
  

• Use (brackets {} or parentheses () are required)

  var i = 3
  myWhile (i > 0) {
    println ("i= " + i)
    i = i - 1   
  }
  

Summary