Section 2.3 Functions (II).

Arguments passed by value and by reference.

int x=5, y=3, z;
z = addition ( x , y );

This way, when function addition is being called the value of its variables a and b become 5 and 3 respectively, but any modification of a or b within the function addition will not affect the values of x and y outside it, because variables x and y were not passed themselves to the the function, only their values.

But it might be a case where you need to manipulate from inside a function the value of an external variable. For that we will have to use arguments passed by reference, as in the function duplicate of the following example:

// passing parameters by reference
#include <iostream.h>

void duplicate (int& a, int& b, int& c)
{
  a*=2;
  b*=2;
  c*=2;
}

int main ()
{
  int x=1, y=3, z=7;
  duplicate (x, y, z);
  cout << "x=" << x << ", y=" << y << ", z=" << z;
  return 0;
}

The first thing that should call your attention is that in the declaration of duplicate the type of each argument went followed by an ampersand sign (&), that indeed serves to specify that the variable has to be passed by reference instead of by value, as usual.

When passing a variable by reference we are passing the variable itself and any modification that we do to that parameter within the function will have effect in the passed variable outside it.

To express it somehow, we have associated a, b and c with the parameters used when calling the function (x, y and z) and any change that we do on a within the function will affect the value of x outside. Any change that we do on b will affect y, and the same with c and z.

That is why our program's output, that shows the values stored in x, y and z after the call to duplicate, shown the values of the three variables of main duplicated.

If when declaring the following function:

void duplicate (int& a, int& b, int& c)

void duplicate (int a, int b, int c)

This type of declaration "by reference" using the ampersand (&) sign is exclusive of C++. In C language we had to use pointers to do something equivalent.

Passing by reference is an effective way to allow a function to return more than one single value. For example, here is a function that returns the previous and next numbers of the first parameter passed.

// more than one returning value
#include <iostream.h>

void prevnext (int x, int& prev, int& next)
{
  prev = x-1;
  next = x+1;
}

int main ()
{
  int x=100, y, z;
  prevnext (x, y, z);
  cout << "Previous=" << y << ", Next=" << z;
  return 0;
}

Dafault values in arguments.

// default values in functions #include <iostream.h> int divide (int a, int b=2) { int r; r=a/b; return (r); } int main () { cout << divide (12); cout << endl; cout << divide (20,4); return 0; }

6 5

As we can see in the body of the program there are two calls to the function divide. In the first one:

divide (12)

In the second call:

divide (20,4)

Overloaded functions.

// overloaded function
#include <iostream.h>

int divide (int a, int b)
{
  return (a/b);
}

float divide (float a, float b)
{
  return (a/b);
}

int main ()
{
  int x=5,y=2;
  float n=5.0,m=2.0;
  cout << divide (x,y);
  cout << "\n";
  cout << divide (n,m);
  return 0;
}

In this case we have defined two functions with the same name, but one of them accepts two arguments of type int and the other accepts them of type float. The compiler knows which to call in each case examining the types when the function is called, if it is called with two ints as arguments it calls to the function that has two int arguments in the prototype and if it is called with two floats it will call to the one which has two floats in its prototype.

For simplicity I have included the same code within both functions, but this is not compulsory. You can build two function with the same name with completely different behaviors.

inline functions.

Its format is:
inline type name ( arguments ... ) { instructions ... }
and the call is just like the one for any other function. It is not necessary to include the inline keyword in the call, only before the declaration.

Recursivity.

n! = n * (n-1) * (n-2) * (n-3) ... * 1

5! = 5 * 4 * 3 * 2 * 1 = 120

// factorial calculator
#include <iostream.h>

long factorial (long a)
{
  if (a > 1)
   return (a * factorial (a-1));
  else
   return (1);
}

int main ()
{
  long l;
  cout << "Type a number: ";
  cin >> l;
  cout << "!" << l << " = " << factorial (l);
  return 0;
}

Notice how in function factorial we included a call to itself, but only if the argument is greater than 1, since if not the function would perform an infinite loop in which once it arrived to 0 it would continue multiplying by all the negative numbers (probably provoking a stack overflow on runtime).

This function has a limitation because of the data type (long) used for designing it for more simplicity: in a standard system, the type long would not allow to store factorials greater than 12!.

Prototyping functions.

But there is an alternative way to avoid to write all the code of all functions before they can be used in main or in another function. It is by prototyping functions. This consists on making a previous shorter declaration of the complete definition but quite significant so that the compiler knows the arguments and the return type needed.

Its form is:

type name ( argument_type1, argument_type2, ...);

• It does not include a statement for the function. That means that it does not include the body with all the instructions that are usually enclosed within key brackets { }.
• It ends with a semicolon sign (;).
• In the argument enumeration it is enough to put the type of each argument. The inclusion of a name for each argument as in the definition of a standard function is optional, although recommendable.

// prototyping
#include <iostream.h>

void odd (int a);
void even (int a);

int main ()
{
  int i;
  do {
    cout << "Type a number: (0 to exit)";
    cin >> i;
    odd (i);
  } while (i!=0);
  return 0;
}

void odd (int a)
{
  if ((a%2)!=0) cout << "Number is odd.\n";
  else even (a);
}

void even (int a)
{
  if ((a%2)==0) cout << "Number is even.\n";
  else odd (a);
}

This example is indeed not an example of effectiveness, I am sure that at this point you can already obtain the same result with half the number of code lines. But this serves to show how protyping works. Moreover, in this concrete case the prototyping of -at least- one of the two functions is necessary.

The first things that we see are the prototypes of functions odd and even:

void odd (int a);
void even (int a);

Many programmers recommend that all functions should be prototyped. It is also my recommendation, mainly in case that there are many functions or in the case that these are very long, since, having the prototype of all the functions in the same place can spare us some time when consulting how to call it.

© The C++ Resources Network, 2000-2001 - All rights reserved

Previous: 2-2. Functions (I).

index

Next: 3-1. Arrays. String of characters.