Void Functions

However strange it may seem, sometimes we do not want a function to return a value. Now why would we want to do something as crazy as that??

• We may only want the side-effects of the function, e.g., printing.
• To return more than one value, we will use something nifty termed call by reference, which will be explained in further detail below.

void PrintInt(int n)
{
  cout << n << endl;
}

PrintInt(7);

Notes:

• Notice there is not return statement needed above. This is because the end of the definition is an implicit return.
• It is OK to put in the return statement but include no expressions after the keyword return:

  return;

• You can also put the return statement anywhere, not just at the end. As always, there is 2 schools of thought on this style:
  • The first school tells its underlings that the function should have just one point of exit. Therefore we don't use a return statement in a void function and we use only one return in a non-void function.
  • The more lenient school tells its students to do whatever is clearest and cleanest. If that means multiple exit points, then by all means do it.
  I come from the more lenient school.

Call by Reference

This is the neat way in which you can make a change to a formal parameter while also affecting the corresponding actual parameter. We do this by using the '&' before the formal parameter in the function header. See CallByReference.ccp Demo

Now one might ask, "How am I going to keep track of such a complicated mess?" You do this by playing CHASE THE ARROW (which is sort of like chasing your tail, but much more productive!!)

• The computer doesn't copy value of actual parameter.
• It instead copies the location of the actual parameter in memory.
• And the called function knows that it got the location of the actual parameter rather than its value. How does it do this... You guessed it: by the prototype!!!

Now think about this...

What must the actual parameter be??? Well, since the call by reference changes the actual parameter it must be a variable .

AND ANOTHER THING!!

Names have nothing to do with parameter correspondence.

void bozo(int &a, int &b)
{
  a = 5;
  b = 7;
}

int a,b;
bozo(b,a);
cout <<< a << b;    //prints 7 5

And the more studious ask...

What about a function that calls a function that calls another function?? How do we deal with that?? And yet another example...

void SQR(double &x)
{
  x = x * x;
}

void POWERS(double n, double &nSquared, double &twoToN)
{
  twoTon = pow(2.0,n);
  nSquared = n;
  SQR(nSquared);
}

Note:

For the parameter x in SQR, you can either trace it to POWERS and then to MAIN, or you can trace it right to MAIN itself. Both have been shown to you above.

When to use call by reference vs.function return value

• If there is only one value to return, use function return value.
• If there is more than one value to return, then use reference parameters.
• AND OF COURSE, THE FLY IN THE OINTMENT...
  • If one of the computed values is a condition (true/false) that you can use in a control statement (if, for, while, do-while), make it be a function return value (and let the other computed values be reference parameters).

This is a function that asks the user whether to type a number and gives back the number if yes.

int ask(double &x)
{
  char answer;

  do {
    cout << "Enter a number? (y/n) ";
    cin >> answer;
    }
  while (answer != 'y' && answer != 'n');

  if (answer == 'y) {
    cout << "OK, enter it: ";
    cin >> x;
    }

  return answer == 'y';
}

And the call...

double s;
  .
  .
  .
if (ask(s)) {
  // code that uses s
  };

Overloading - C++ feature NOT in C

Overloading is nothing more than using the same function name for multiple functions. Which function body is actually used is determined by number and types of actual parameters. Overloading is best used for functions that do essentially the same thing when given different types. See Demo GAA,cpp

BEWARE!!!! Overloading is a double-edged sword. It can help, but it can also be used to create deceptive code. (Not nice to deceive your graders) So please be careful!!!