Introduction to Scientific Programming Computational Problem Solving Using: Maple and C Mathematica and C Author: Joseph L. Zachary Online Resources: Maple/C Version Mathematica/C Version

C Functions Tutorial

In this tutorial you will experiment with programmer-defined functions in C, as discussed in Chapter 12. You will be using some example programs. You can use your Web browser to download them.

The Need for Functions

You do not have to write many programs before you realize that you would like to use a function that is not provided by C. Fortunately, it is easy to define and use your own functions. In this section we will look at a simple example of how to do that.

Download log1.c and read it into Emacs. Whereas C provides a function named log10 to compute base ten logarithms, it provides no corresponding function for other integer-valued bases. Because of this, log1.c uses the log10 function to compute logarithms for bases 2 through 9 according to a standard mathematical formula.

If there were a standard function, say logbase, to compute base b logarithms, our program would be simplified in the following ways:

• We wouldn't have to memorize (or even know) the formula for computing base b logarithms.

• We wouldn't have to duplicate the formula for base b logarithms every time we needed to compute one. It appears eight times in log1.c, which is probably tolerable. But what if it appeared dozens or even hundreds of times? Every time it appears is another opportunity for making a typographical mistake.

The program log2.c shows what log1.c would look like if a logbase function existed in math.h. If you try to compile it, however, the compiler will complain that it doesn't know anything about the logbase function. If we want to use logbase in our program, we will also have to implement it.

The program log3.c is identical to log2.c except that it also contains an implementation of the programmer-defined function logbase. This program will compile, run, and produce the same results as our original log1.c.

Function Interfaces

The implementation of logbase appears near the top of log3.c, and is:

    /* Returns the log base b of y. */

    double logbase (double y, int b)
    {
      double lg;
      lg = log10(y)/log10(b);
      return(lg);
    }

The comment together with the first line of the function (known as the header) tell us everything that we need to know in order to make use of logbase. This information, which is called the interface of the function, includes

• the name of the function (logbase),

• the number (2) of its parameters,

• the types (double and int) of its parameters,

• the type (double) of value that it returns, and

• the information that it calculates the logarithm of its first parameter (y) to the base specified by its second parameter (b).

The comment and the header make it possible to understand what logbase does without having to read the balance of its implementation.

Using Functions

A programmer-defined function is called in exactly the same way as a built-in function. The main function of log3.c contains eight different calls to logbase; the first one, for example, is

    logbase(x,2);

which calculates the log base 2 of x.

It is important to use a programmer-defined function in a way that is consistent with its interface; otherwise, you will get compiler errors or unexpected results. To understand this point better, and to get an idea of what kinds of errors you can expect, try these experiments with this line of code from log3.c,

    printf("The base 2 logarithm of %g is %g\n", x, logbase(x,2));

which is the first line in the main function that makes use of logbase. (After each experiment, change log3.c back to its original form.)

• Use the wrong name for the function. Change logbase(x,2) to logbse(x,2). Compile the program and note the error message.

• Use the wrong number of parameters. Change logbase(x,2) to logbase(x,2,3). Compile the program and note the error.

• Use the wrong types of parameters. Change logbase(x,2) to logbase(x,3.7). Compile and run the program. Notice that when you pass a double where an integer is expected, the fractional part of the double is discarded.

• Assume the wrong type for the returned value. Change the second format specification (%g) to %d. In other words, specify that the value returned by logbase(x,2) is to be displayed as an integer. Compile the program and note the error message.

Function Calls

When a programmer-defined function is called, C follows a well-defined sequence of steps. For example, let's consider what happens when logbase(x,2) is called.

• The actual parameters (the values specified in the function call) are evaluated. In our example, the value of x is looked up to obtain a double, which we will assume to be 16.0; the value of the second actual parameter is the integer 2.

• A table is created to contain the values of the variables declared in the function being called. Those variables include the formal parameters (which are declared in the header of the function) and the local variables (which are declared in the body of the function). In the case of logbase, the table would look like

• Each formal parameter in the table is initialized to the value of its corresponding actual parameter. In the case of our example, the table would look like

  y 16.0

  b 2 lg

  Notice that the first actual parameter supplies the initial value of the first formal parameter, and so on. The names used for the actual and formal parameters have nothing to do with one another. That is why we can pass the value of an actual parameter x to a formal parameter y, and the value of an actual parameter 2 to a formal parameter b.

• The body of the function, in this case

        lg = log10(y)/log10(b);
        return(lg);

  is evaluated, using the just-created table to look up and store the values of variables. When a return statement is encountered, the specified value (in this case lg, which would be 4.0), is returned to the point of call as the result. The variable table is discarded, and execution continues at the original point of call just as if a built-in function had been called.