Function Prototypes and
an Overview of Functions with Address Parameters, Arrays, and Testing

Introduction

As we have explored problem solving using C, main topics have included variables for several types of data, control structures, such as conditional statements (if, switch), loops (for, while), program organization including simple functions, and assertions.

To move our problem solving to a deeper and more sophisticated level, the next step is to explore two issues:

• Minor issue: The declaration of functions must provide adequate information for the compiler to perform its work.

• Major issue: Additional capabilities with functions and the capability to work with collections of data both require an understanding of the allocation of space for data within the computer's main memory.

This reading addresses the minor issue, by introducing the concept of function prototypes. The rest of this course segment discusses the storage of data within a computer's main memory, focusing on three foundational topics:

• The run-time stack: The allocation and deallocation of main memory, when functions are called and when they return,

• Parameter passage of values and addresses: Storage and access to parameters and data in the context of functions, and

• Arrays: Storage of several data values within the context of a single variable name.

Function Prototypes

Consider the work of a compiler. A compiler reads a C program line-by-line and translates each statement to machine language, so the resulting code can be run. Although the art of constructing an efficient and effective compiler requires considerable skill, some elements are relatively straight forward:

• The declaration of a variable allows the compiler to allocate the appropriate amount of space for the relevant type of data.

• Rules dictate what machine operations should be used for various arithmetic operations. Since int, float, double data are stored in different ways (more about the representation of data in a later course segment), a compiler can examine the data types of each value and/or variable to utilize the appropriate machine instructions for the prescribed work.

• Rules also dictate when conversions of data are to take place. For example, when an int is added to a double, C specifies that the int should be converted automatically to a double before the addition is performed.

Challenges arise, however, when functions are used. As a simple example, consider the following function that adds 2.0 to its parameter and returns the result.

double add2 (double value)
{
   return 2.0 + value;
}

Now suppose the main program contains the following lines:

int x = 5;
double y = add2(x);

If the compiler knows about this function before it encounters the expression add2(x), then the compiler will recognize that the int 5 must be converted to the double 5.0 before the function is applied. However, if the compiler has not encountered the definition of add2 previously, the compiler could not know whether the parameter for add2 should be an int or double.

Given this possible confusion, C allows three approaches.

• If the function is defined before it is used, the compiler uses the function header to determine parameter types and the return type. (Likely, this is what a programmer would expect.)

• If the function is not defined before it is used, the compiler examines the actual parameters from the function call (e.g., the variable x in the example).

  • If the actual parameter supplied is some type of integer (e.g., short, int, unsigned short, or unsigned int), C assumes the parameter is supposed to be an int.
  • If the actual parameter supplied is a type of real number (e.g., float or double), C assumes the parameter is supposed to be a double.

• If a function has not been formally defined, C allows a programmer to provide a function prototype — the function header without the braces or the function body. For example, a file might contain the prototype near the start of the program:

  double add2 (double value);
  

  In this case, the compiler will know that the parameter will be a double, and thus the compiler will not have to guess what to do with the call add2(x) — the compiler will know that the integer x must be converted to a double before the function add2 is called.

Altogether, a function prototype provides information about the parameters and return type of a function at the start of a program. In summary, a function prototype allows a compiler to generate appropriate code, even if the full details of a function have not yet been given within a program. Of course, if a function prototype is used, the full definition of the function (duplicated header together with the function body) must be defined before the program can be run.

Using Function Prototypes and Supplying Function Details

Program add2.c illustrates a complete program using the add2 function prototype early in the code and giving the details of the function near the end.

/* Program illustrating a function prototype near the start of the code
   and the full function definition near the end.
*/

#include <stdio.h>

/* function to add 2 to a value and return the result */
double add2 (double value);   // function prototype, with semi-colon at end

int main ()
{
  printf ("program illustrating a function prototype\n");
  int x = 5;
  double y = add2(x);         // function used

  printf ("x = %d, y = %lf\n", x, y);

  return 0;
}

/* function to add 2 to a value and return the result */
double add2 (double value)   // function details given here
{
   return 2.0 + value;
}

Why Use Function Prototypes?

Although the program add2.c illustrates how function prototypes can be defined and used, a student still may wonder why? Why not just remove the function prototype in a program and place the function header, with its function body, at the start of the code?

Frankly, for program add2, moving the function header and body to the top of the code, replacing the function prototype, would work fine! However, for more complex problems and environments, there can be at least three motivations for the use of function prototypes.

• Construction and use of libraries: Development of software often involves the use of various C libraries. For example, work with Scribbler 2 robots takes advantage of the MyroC infrastructure package. In using this material, a separate header file MyroC.h. A careful examination of this file shows that this header file is a listing of function prototypes — the file identifies the various MyroC functions, including their parameters and return types. Similarly, the header files for stdio.h, stdlib, time.h, assert.h, etc. all specify function prototypes.

  When using these libraries, the #include statement effectively copies the function prototypes into the program, so the compiler will know what parameter names, parameter types, and return types to expect.

• Program organization: When a program includes many functions, the list of functions, with their function bodies, can be quite long — extending to many pages. Unfortunately, in practice, searching through the many pages to find function headers is time consuming. Instead, collecting function prototypes together at the start of a program can serve as a convenient index or directory of what functions are defined and what parameters are specified in which order.

• Functions that call each other: In some contexts, problem solving yields multiple functions that call each other. For example, function A might call function B, but function B also might call function A. Function prototypes are essential in this context.

  Functions that call each other are said to be recursive. The subject of recursive functions and recursive algorithms is deferred to a later time.