Parameter Passing in C and C++
P. Conrad for CS16, UC Santa Barbara, Spring 2010

Two (well, maybe three) ways to pass parameters in C

When passing parameters to a function, there are two ways it can happen—well, three if you count passing an array as a separate way:

1. Passing by value—e.g. int myFunc(int x);—the value is copied from an expression in the caller to an expression in the callee
2. Passing by pointer—e.g. int myFunc(int *p); a pointer is passed from the caller to the callee.
• This pointer is often the address of a variable in the caller.
• This allows the callee to directly access the variable in the caller by dereferencing the pointer.
• That means the value can be pulled out of the variable in the caller (used on the right hand side of an assignment), e.g. int x = (*p);
• This means the value of the variable in the caller can also be changed, by dereferencing the pointer on the left hand side of an assignment statement (e.g. (*p) = 5;
3. Passing an array—e.g. int myFunc(int nums[], int n); which is really just a special case of passing a pointer—essentially another way of writing int myFunc(int *nums, int n);
   • In C and C++, the name of an array is a pointer to the first element of the array.
   • So, when you pass an array name, you are really passing a pointer.
   • And, saying a[i] is really just a shorthand for *(a+i), so when you access an array parameter in C, you are accessing the array in the caller.

We've been over these in lecture, and they are covered in your Etter textbook—so the information above is really just review.

The overworked ampersand

In C++, there is yet one more way to pass parameters, and the syntax can be a bit confusing—it adds yet another meaning for the overworked ampersand. So before we go there, let's review the meaning that the ampersand already has:

1. As a unary operator in an expression it means address of (e.g. scanf("%i",&x); )
   • e.g. the right hand side of an assignment, or an actual parameter in a function call)
2. As a binary operator it means bitwise and (e.g. printf("%i\n",x & y);)
   • see homework H22 and the reading assignment that went with it for a review of bitwise and
3. As a binary operator doubled up it means logical and (e.g. if (x!=0 && y!=0)
   • this always returns either 1 or 0, the C values for true or false

C++ adds yet one more way to pass parameters: reference parameters (aliases)

In C++, there is yet one more way to pass parameters. It is very similar to the way passing by pointer works in C, but the syntax is simplified.

In C, to pass by pointer, in the callee, we write something like what you see below in squareIt.c at the left, if, for example, the effect we want is that the variable passed in gets its value squared. Note the following:

• In the callee, the formal parameter is of type int *, that is, pointer to integer
• In the caller, the actual parameter is also of type int *—we have to use the & operator to turn the int into an int *, by taking its address. (As we've discussed, an address is a pointer, and a pointer is an address.)

In C++, we can still write exactly the same code—the example on the left is valid C++. However, there is another option, as shown on the right in the file squareIt.cpp (as you may recall, .cpp is one of the valid filename endings for C++ code.)

The effect of the C++ code is exactly the same as that of the C code, but the syntax is simplified.

Look at the syntax in the C++ example for the function header: void squareIt(int &x) and note that the & here does NOT MEAN ADDRESS OF. This is different from the address of syntax because the & occurs in front of a variable that is a formal parameter—when it occurs here, in the header of a function definition or a function prototype, it means that the parameter is a reference parameter. A reference parameter can be thought of "similar passing by pointer, but with automatic transmission as opposed to standard transmission". That is:

• In the function call, you don't have to use the & in front of the actual parameter
• In the function definition body, you don't have to use the * in front of the formal parameter variable to dereference it every time it occurs.

A reference parameter creates an alias—in this example, inside the function squareIt, x is an alias for a in the main program. (We could also say that in the C example, (*p) is an alias for a.)

// squareIt.c
#include 

void squareIt(int *p)
{
  (*p) = (*p) * (*p);
}

int main()
{
  int a=5;
  squareIt(&a);
  printf("a=%i\n",a);
  return 0;
}

// squareIt.cpp (using C style I/O)
#include 

void squareIt(int &x)
{
  x = x * x;
}

int main()
{
  int a=5;
  squareIt(a);
  printf("a=%i\n",a);
  return 0;
}