CISC 3142
Programming Paradigms in C++
Parameter Transmission

Parameter Transmission

• By default, C++ passes arguments by value, i.e., a copy of the argument is made and placed in the parameter (which is a local variable in the activation record of the caller on the call stack).
• Declaring the parameter as a reference of the type of the expected argument, turns the parameter transmission into by-reference, i.e., a reference (the address) to the argument is passed (instead of a copy of its value).
  • This permits changes made to a parameter to affect the corresponding argument
    • In C, this effect is achieved via pointers and explicit indirection (i.e., the * operator)
  • Passing by-reference serves another purpose as well … it avoids the copying of the argument to the parameter, which can be a substantial overhead if the argument is large
    • If this is the only reason that the reference is used, the proper practice is to pass by const-reference

      void play(const Video &video) {…}
      				

Practical Rules for Parameter Transmission

Call-By-Reference — Modified Parameter is to be Passed Back to Argument

• If a value is to be passed back via the parameter (i.e., modifications to the parameter are to affect the argument), call-by-reference (T &) should be used.

  void minmax(int x, int y, int z, int &min, int &max);
  		

  void read(Rational &r);
  		

  • Parameters passed using either of the other two modes — by-value or by-const-reference — will not effect a change:
    • with by-value, all changes are restricted to the local variable (which receives a copy of the argument, and which is then destroyed upon returning from the function),
    • for by-const-reference, the compiler will prohibit any changes to the parameter within the function

Call-By_Const_Reference — Avoiding the Argument-to-Parameter Copy

• If the parameter is class (or struct) object (i.e., a variable whose type is a structure or class) and is not being modified, it should be passed by-const-reference

  class Rational {
  	…
  	… add(const Rational &r);
  	…
  };
  		

  • This will avoid the cost of creating the copy (memory allocation, copying values, constructor invocation)

Call-By-Value

• If the parameter is a predefined fundamental type (int, long, double, bool, char, float) and is not being modified, the parameter should be passed by-value (T).

  int abs(int i);
  		

  • There is no reason to pass by-const-reference since the predefined types are small in size, and there is no benefit to passing a reference rather than performing an actual copy of the argument itself

const Member Function — Preventing the Receiver (*this) From Being Modified

• The semantics of many member functions do not call for a change in the receiving object (this), e.g.
  • Returning the length of a string or the size of a container does not change the container
  • Returning the i'th element of a vector does not change the vector
  • Adding another Rational to a receiving Rational and returning a third (new) Rational as the result does not change the receiver
    • OTOH, addInPlace DOES change the receiver.
• member functions that do not modify the receiving object are called const member functions
• The receiver is often referred to as the implicit parameter as it is not explicitly passed in the call (i.e., it does not appear in the argument list).
• As such, while all other parameters can be declared const there is no 'obvious' way to do so for the receiver.
• C++ provides the following syntax for declaring a const member function:

  class Rational {
  	…
  	int getNumerator() const;
  	void print() const;
  	…
  };
  		

Return Value Transmission

• The same arguments hold for the return type — we try to avoid the copy overhead whenever possible for non-scalars
• The return value is typically:
  • used as an operand in a larger expression

    x + f(y)
    				

  • assigned to a variable

    x = f(y);
    				

    • As an aside this is nothing more than a particular case of the previous bullet; i.e., in this situation, the return value is the left hand operand of the (larger) expression x = f(y)
  • used as an argument to another function (composition)

    System.out.println(f(y));
    				

    g(a, b, f(y), d);
    				

    • Similar remark — the return value is being used in a larger expression (the outer function call)
    In general, the return value is copied from its location on the call stack (the compiler allocates space for it together with the local variables) to some memory location in the caller (often a temporary).
• There IS one significant difference between passing parameters and returning values: if the value to be returned is a local variable (i.e., an object whose lifetime will be terminated upon exit from the function), one cannot return a pointer or reference to that object (as the object will no longer be in existence, and it's memory location will be reused).

  int &f() {
  	int x = 10;
  	return x;
  }
  …
  int y = f();		// trying to assign to y a value from the location of x, which is no longer valid
  		

  • Doing so would result in a dangling reference, i.e., a pointer or reference to a location no longer associated withe the object.
  • Current compilers flag this as an error, previously it was a warning, and before that, something the programmer had to be careful of.
  • This would be equally true in the case of returning a pointer to a local variable:

    int *f() {
    	int x = 10;
    	return &x;
    }
    …
    int y = *f();		// trying to assign to y a value by dereferencing a pointer to the location of x, which is no longer a valid location
    				

Practical Rules for Transmitting Return Values

Return-by-Value

• Local variables of any sort, fundamental or class types must be returned by value to avoid the dangling reference issue.

  Rational multiply(const Rational &r) {
  	Rational result;
  	…
  	return result;
  }
  		

  • In the above code, result must be returned by value, since it goes out of scope upon function exit
  • This does introduce the possible overhead of copying a large class object when returning it; we have no choice here
• Fundamental/predefined types (int, double, bool, char, etc) should, in general, be returned by value

  int f();
  		

  • There is no advantage in returning a reference in these cases; again, the objects are small, and thus the copy overhead would be the same as passing the reference
  • There is on situation under which one of these types would be returned by-reference … when the location of the return value is desired (rather than the value) — see below

Return-by-Reference

• class objects should be returned by reference when possible (i.e., if they're not local variables)
  • The most common case of an object that will continue to exist is a parameter passed by reference — the object being referenced existed prior to the function call, and will continue to do so after the function exits (unlike local variables — including by-value parameters — which are created upon function entry (and assigned a copy of the argument) and destroyed upon function exit.

  Rational &multiplyInPlace(const Rational &r) {
  	…
  	return *this;;
  }
  		

  • Again, this is unlike a local variable — including by-value parameters — which are created upon function entry, assigned a copy of the argument, and destroyed upon function exit.
• There is one other situation when we return by-reference (in particular for predefined types like int) — when the returned value is to be used as an lvalue.
  • The classic case for this will be overloading the subscripting operator … we will address it when it becomes relevant.
  • Here is a related example that doesn't use operator overloading

    class Simple {
    public:
    	Simple(int v) : val(v) {}
    	double &value() {return val;}
    private:
    	double val;
    };
    …
    Simple simple(12);
    cout << simple.value() << endl;		// prints 12
    simple.value() = 15;						// assign 15 to simple's val
    				

    • Returning a reference means the location (lvalue) of the object (the data member val — not its value (rvalue) — is being returned
    • When used in a context requiring an rvalue (for example in the statement printing out the return value), the reference is (implicitly) dereferenced to result in the value.
    • When used in a context requiring an lvalue (i.e., a location — for example when the function call is the left operand of the assignment), the lvalue is used.
    • This mirrors the more usual semantics of the assignment statement:
      • for x = y, since y appears in a context requiring an rvalue (its 'value'), we go to the location of y and extract its value/contents.
      • for x — the left operand of the assignment — we are interested in its lvalue (it's location) where we store the value obtained from the right hand operand

Return-by-Const-Reference

• If you are returning a parameter that was passed in as const-reference, then you must return by const-reference as well
  • This is to preserve the 'constness' of the object

One Final Note — Passing-By-Pointer

• This is no longer necessary in C++ where call-by-reference can be used.
• The only reason to have a pointer as an argument/parameter is because one has a pointer that one wishes to pass to a function
  • We'll see examples of this later on with dynamic allocation

Code Used in this Lecture