Parameter-Passing Modes

Contents

• Overview
• Value Parameters
• Reference Parameters
• Const Reference Parameters
• Array Parameters
• Test Yourself #1

In Java, all parameters are passed by value. In C++, a parameter can be passed by:

1. value,
2. reference, or
3. const-reference

void f( int a, int &b, const int &c );

Value Parameters

When a parameter is passed by value, a copy of the parameter is made. Therefore, changes made to the formal parameter by the called function have no effect on the corresponding actual parameter. For example:

void f(int n) {
    n++;
}

int main() {
    int x = 2;
    f(x);
    cout << x;  
}

Note that if a pointer is passed by value, then although the pointer itself is not affected by changes made to the corresponding formal parameter, the object pointed by the pointed can be changed. For example:

void f(int *p) {
    *p = 5;
    p = NULL;
}

int main() {
    int x=2;
    int *q = &x;
    
    f(q);

    // here, x == 5, but q != NULL
}

After executing the two statements:
    int x=2;
    int *q = &x;

memory looks like this:

       +---+
    x: | 2 | <--+
       +---+    |
                |
       +---+    |
    q: | --|----+
       +---+

Now function f is called; the value of q (which is the address of x)
is copied into a new location named p:


       +---+
    x: | 2 | <--+  <--+
       +---+    |     |
                |     |
       +---+    |     |
    q: | --|----+     |
       +---+          |
                      |
       +---+          |
    p: | --|----------+
       +---+

Executing the two statements in f:
    *p = 5;
    p = NULL;

causes the values of x (the thing pointed to by p) and p to be changed:

       +---+
    x: | 5 | <--+
       +---+    |
                |
       +---+    |
    q: | --|----+
       +---+     
                 
       +----+     
    p: |NULL|
       +----+

However, note that q is NOT affected.

When a parameter is passed by reference, conceptually, the actual parameter itself is passed (and just given a new name -- the name of the corresponding formal parameter). Therefore, any changes made to the formal parameter do affect the actual parameter. For example:

void f(int &n) {
    n++;
}

int main() {
    int x = 2;
    f(x);
    cout << x;  
}

When you write a function whose purpose is to compute two or more values, it makes sense to use reference parameters (since a function can return only one result). For example, if you want to read a list of integers from a file, and you want to know both how many integers were read, as well as the average value that was read, you might use a function like the following:

void f(istream &input, int &numRead, double &average) {
    int k, sum = 0;
    numRead = 0;

    while (intput >> k) {
        numRead++;
	sum += k;
    }
    average = (double)sum/numRead;
}

void swap( int &j, int &k ) {
    int tmp = j;
    j = k;
    j = tmp;
}

swap(A[j], A[k]);

Another reason to use reference parameters is when you don't want the function to modify an actual parameter, but the actual parameter is very large, and you want to avoid the overhead of creating a copy. Of course, this only works if the function does not modify its formal parameter. To be sure that the actual parameter is not "accidentally" modified, you should use a const-reference parameter. Declaring the parameter to be const tells the compiler that it should not be changed; if the function does change the parameter, you will get a compile-time warning (possibly an error on some systems). For example:

void f(const IntList &L) {
 -- the code here cannot modify L or the compiler will complain --
}

void f(const IntList &L) {
  L.Print(cout);
}

Another unfortunate thing about C++ arrays is that they are always passed by reference (even though you don't declare them to be reference parameters). For example:

void f(int A[]) {
    A[0] = 5;
}

int main() {
    int B[10];
    B[0] = 2;
    f(B);
    cout << B[0] << endl;  // the output is 5
}

If you want to pass an array by value, you should use a vector, not a regular C++ array (see the last section in the notes on C++ classes for information about vectors).

1. Consider the following code segment.

   void Mystery( int & a, int & b, int c )
   {
        a = b + c;
        b = 0;
        c = 0;
   }
   
   void Print()
   {
        int x = 0, y = 1, z = 2;
   
        Mystery(x, y, z);
        cout << x << " " << y << " " << z;
        Mystery(x, y, z);
        cout << x << " " << y << " " << z << endl;
   }
   

   What is output when function Print is called?

   A. 0 1 2 0 1 2
   B. 3 0 0 3 0 0
   C. 0 1 2 3 0 0
   D. 3 0 2 2 0 2
   E. 3 0 0 0 0 0

2. A function called Sqrt, which is intended to compute and return the square root of its integer parameter, has been written. When the function is tested, it is observed that, although the correct value is returned, the argument passed to Sqrt is always zero after the function call. Which of the following is the most likely explanation for this problem?

   A. Sqrt is written using recursion; it should be written using iteration.
   B. Sqrt is written using iteration; it should be written using recursion.
   C. Sqrt's parameter is a value parameter; it should be a reference parameter.
   D. Sqrt's parameter is a reference parameter; it should be a value parameter.
   E. Sqrt's parameter is a const reference parameter; it should be a value parameter.

3. Consider the following program.

   #include <iostream>
   
   void Sum(int a, int b, int & c)
   {
        a = b + c;
        b = a + c;
        c = a + b;
   }
   
   int main()
   {
        int x=2, y=3;
   
        Sum(x, y, y);
        cout << x << " " << y << endl;
        return 0;
   }
   

   What happens when this program is compiled and executed?

   A. There is a compile-time error because in the call Sum(x, y, y), variable y is passed both by value and by reference.
   B. There is a run-time error because in the call Sum(x, y, y), variable y is passed both by value and by reference.
   C. The program compiles and executes without error. The output is: 2 3
   D. The program compiles and executes without error. The output is: 6 9
   E. The program compiles and executes without error. The output is: 2 15

   Questions 4 and 5 refer to the following function.

   bool Mystery(const vector <int> & A)
   // precondition: A is sorted
   {
        int k;
   
        for (k=1; k<A.size(); k++)
        {
             if (A[k-1] == A[k]) return true;
        }
        return false;
   }
   

4. Which of the following best explains what function Mystery does?

   A. Always returns true.
   B. Always returns false.
   C. Determines whether vector A really is sorted.
   D. Determines whether vector A contains any duplicate values.
   E. Determines whether all values in vector A are the same.

5. Which of the following best explains why A is a reference parameter?

   A. A may be modified by function Mystery; thus, it must be a reference parameter.
   B. A is indexed by function Mystery; thus, it must be a reference parameter.
   C. A's size member function is used by function Mystery; thus, it must be a reference parameter.
   D. It is more efficient to pass A by reference than by value.
   E. There is no reason for A to be a reference parameter.