Department of Engineering

IT Services


Functions are used to divide a program up into smaller more manageable components. The basic structure is the same as the main program (which is itself just a function called main). The general form is:

<return_type> procname(<parameter_type_1> p1, <parameter_type_2> p2 ...)
   <type_1>    ...;
   <type_2>    ...;

   return <value of type return_type>;

Note that the body of the function is a block, as described in section 9, and that variables declared within the function behave as described in section 9.

Example: definition of a factorial function, and a function to calculate nCr:

// Factorial function declaration (prototype)
int factorial(int n);

// Combinations function definition
int combinations(int n, int r)
   return factorial(n) / (factorial(n - r)*factorial(r));

// Factorial function definition
int factorial(int n)
   int answer = 1;

   // Calculate the factorial with a FOR loop
   for (int i = 1; i <= n; ++i)
      answer = answer * i;

   return answer;

The value (of type return_type) returned by a function can be used as a component of an expression. Thus given the above functions and the variables total, count and comb also of type int, the following expression and assignment may be used compute totalCcount and store the result in comb:

comb = combinations(total, count);

The formal parameters of a procedure (e.g. int n and int r in combinations) specify the name and type for each argument. A formal parameter preceded by & indicates call by reference. The corresponding actual parameter must be a variable of the same type, and statements within the function can modify its value.

If the & is omitted then call by value is indicated. The actual parameter can be any expression yielding a value of the required type, and a copy is assigned to the corresponding formal parameter, i.e. it is an input-only parameter. The parameters for factorial and combinations are all passed by value.

Declaring the function to be of type void indicates that no value is returned by the call. The following functions illustrate void and call by reference:

void swap(float &a, float &b)
// Swaps x and y data of calling function. 
   float tmp;
   tmp = b;
   b = a;
   a = tmp;

void sort(float data[], int length)
   int      minj;
   float    min;

   for (int i = 0; i < length-1; i++)
      minj = i;
      min = data[i];
      for (int j = i+1; j < length; j++)
         if (data[j] < min)
            minj = j;
            min = data[j];
      if (minj > i)
         swap(data[minj], data[i]);

Arrays are always passed by reference, and the function can access and/or modify all the elements of the array. This avoids the expense of making a copy of each element of the array.

Functions may call themselves (and others) recursively, as illustrated in the following version of the factorial function:

int r_factorial(int a)
   int result;

   if (a <= 1)
      result = 1;
      result = a * r_factorial(a - 1);   // recursive call

   return result;