5. Fruitful functions

5.1. Return values

Some of the built-in functions we have used, like the math functions, have produced results. That is, the effect of calling the function is to generate a new value, which we usually assign to a variable or use as part of an expression. For example:

double e = exp(1.0);
double height = radius * sin(angle);

But so far all the functions we have written have been void functions; that is, functions that do not return a value. When you call a void function, it is typically on a line by itself, with no assignment:

n_lines(3);
countdown(n-1);

In this chapter we are going to write functions that return things, which we will refer to as fruitful functions. The first example is area, which has a double parameter, radius, and which returns the area of a circle with the given radius:

double area(double radius) {
    double pi = acos(-1.0);
    double area = pi * radius * radius;
    return area;
}

The first thing you should notice is that the beginning of the function definition is different. Instead of void, which indicates a void function, we see double, which indicates that the return value from this function will have type double.

Also notice that the last line is an alternative form of the return statement that includes a return value. The statement means, “return immediately from this function and send the value of the following expression to the caller.” The expression you provide can be arbitrarily complicated, so we could have written this function more concisely:

double area(double radius) {
    return acos(-1.0) * radius * radius;
}

On the other hand, temporary variables like pi and area often make your program easier to read and debug. In either case, the type of the expression in the return statement must match the return type of the function. In other words, when you declare that the return type is double, you are making a promise that this function will eventually produce a double. If you try to return with no expression, or an expression with the wrong type, the compiler will take you to task.

Sometimes it is useful to have multiple return statements, one in each branch of a conditional:

double absolute_value(double x) {
    if (x < 0) {
        return -x;
    } else {
        return x;
    }
}

Since these return statements are in an alternative conditional, only one will be executed. Although it is legal to have more than one return statement in a function, you should keep in mind that as soon as one is executed the function terminates without executing any subsequent statements.

Code that appears after a return statement, or any place else where it can never be executed, is called dead code. Some compilers warn you if part of your code is dead.

If you put return statements inside a conditional, then you have to guarantee that every possible path through the program hits a return statement. For example:

double absolute_value(double x) {
    if (x < 0) {
        return -x;
    } else if (x > 0) {
        return x;
    }
}                     // WRONG!!

The program is not correct because if x happens to be 0, the neither condition will be true and the function will end without hitting a return statement. Unfortunately, many C++ compilers do not catch this error. As a result, the program may compile and run, but the return value when x is 0 could be anything, and will probably be different in different environments.

By now you are probably sick of seeing compiler errors, but as you gain more experience, you will realize that the only thing worse than getting a compiler error is not getting a compiler error when your program is wrong.

Here’s the kind of thing that’s likely to happen: you test absolute_value with several values of x and it seems to work correctly. Then you give your program to someone else and they run it in another environment. It fails in some mysterious way, and it takes days of debugging to discover that the problem is an incorrect implementation of absolute_value. If only the compiler had warned you!

From now on, if the compiler points out an error in your program, you should not blame the compiler. Rather, you should thank the compiler for finding your error and sparing you days of debugging. Some compilers have an option that tells them to be extra strict and report all the errors they can find. You should turn this option on all the time.

As an aside, you know that there is a function in the math library called fabs that calculates the absolute value of a double correctly.

5.2. Program development

At this point you should be able to look at complete C++ functions and tell what they do. But it may not be clear yet how to go about writing them. We are going to suggest on technique called incremental development.

As an example, imagine you want to find the distance between two points, given by the coordinates \((x_1, y_1)\) and \((x_2, y_2)\). By the usual definition,

\[distance = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}\]

The first step is to consider what a distance function should look like in C++. In other word, what are the inputs (parameters) and what is the output (return value).

In this case, the two points are the parameters, and it is natural to represent them using four doubles. The return value is the distance, which will also have type double.

Already we can write an outline of the function:

double distance(double x1, double y1, double x2, double y2) {
    return 0.0;
}

The return statement is a placekeeper so that the function will compile and return somthing, even though it is not the right answer. At this stage the function doesn’t do anything useful, but it is worthwhile to try compiling it so we can identify any syntax errors before we make it more complicated.

Somewhere in main we should add:

double dist = distance(1.0, 2.0, 4.0, 6.0);
cout << "dist is: " << dist << endl;

We chose these values so that the horizontal distance is 3 and the vertical distance is 4; that way the result will be 5 (the hypotenuse of a 3-4-5 triangle). When you are testing a function, it is useful to know the right answer.

Once we have checked the syntax of the function definition, we can start adding lines of code, a little at a time. After each incremental change, we recompile and run the program. That way, at any point we know exactly where a new error must be - in the last changes we made to the program.

The next step in the computation is to find the differences \(x_2 - x_1\) and \(y_2 - y_1\). We will store these value in temporary variables named dx and dy.

double distance(double x1, double y1, double x2, double y2) {
    double dx = x2 - x1;
    double dy = y2 - y1;
    cout << "dx is " << dx << endl;
    cout << "dy is " << dy << endl;
    return 0.0;
}

We added output statements that will let us check the intermediate values before proceeding. As mentioned, we already know that they should be 3.0 and 4.0.

When the function is finished we will remove these output statements. Code like this is called scaffolding, because it is helpful in building the program, but it is not part of the final product. Sometimes it is a good idea to keep the scaffolding around, but comment it out, just in case you need it later.

The next step in the development is to square dx and dy. We could use the pow function, but it is simpler and faster to just multiply each term by itself.

double distance(double x1, double y1, double x2, double y2) {
    double dx = x2 - x1;
    double dy = y2 - y1;
    double dsquared = dx * dx + dy * dy;
    cout << "dsquared is " << dsquared << endl;
    return 0.0;
}

Again, you should compile and run the program at this stage and check the intermediate value (which should be 25.0).

Finally, we can use the sqrt function to compute and return the result (remember to include the cmath library).

double distance(double x1, double y1, double x2, double y2) {
    double dx = x2 - x1;
    double dy = y2 - y1;
    double dsquared = dx * dx + dy * dy;
    double result = sqrt(dsquared);
    return result;
}

Then in main, we should output and check the value of the result.

As you gain more experience programming, you might find yourself writing and debugging more than one line at a time. Nevertheless, this incremental development process can save yiou a lot of debugging time.

The key aspects of the process are:

• Start with a working program and make small, incremental changes. At any point, if there is an error, you will know exactly where it is.

• Use temporary variables to hold intermediate values so you can output and check them.

• Once the program is working, you might want to remove some of the scaffolding or consolidate multiple statements into compound expressions, but only if it does not make the program difficult to read.

5.3. Composition

As you should expect by now, once you define a new function, ou can use it as part of an expression, and you can build new functions using existing functions. For example, what if someone gave you two points, the center of a circle and a point on its perimeter, and asked for the area of the circle?

Let’s say the center point is stored in the variables xc and yc, and the permimeter point is in xp and yp. The first step is to find the radius of the circle, which is the distance between the two points. Fortunately, we have a function, distance, that does that. we have a function, distance, that does that. we have a function, distance, that does that. we have a function, distance, that does that.

double radius = distance(xc, yc, xp, yp);

The second step is to find the area of the circle with that radius, and return it.

double result = area(radius);
return result;

Wrapping that all up in a function, we get:

double anna(double xc, double yc, double xp, double yp) {
    double radius = distance(xc, yc, xp, yp);
    double result = area(radius);
    return result;
}

5.4. Overloading

In the previous section you might have noticed that anna and area perform similar functions - finding the area of a circle - but have different paramenters.

For area, we have to provide the radius; for anna we provide two points.

If two functions do the same thing, it is natural to give them the same name. In other words, it would make more sense if anna were called area.

Having more than one function with the same name, which is called overloading, is legal in C++ as long as each version has different parameters. So we can go ahead and rename anna:

double area(double xc, double yc, double xp, double yp) {
    return area(distance(xc, yc, xp, yp));
}

This looks like a recursive function, but it is not. Actually, this version of area is calling the other version. When you call an overloaded function, C++ knows which version you want by looking at the number and types of the arguments that you provide. The name of a function together with the sequence of types of its parameters is called the function’s signature. For example, if you write:

double x = area(3.0);

C++ looks for a function named area with a single double as a parameter, so it will use the first version. If you write:

double x = area(1.0, 2.0, 4.0, 6.0);

C++ will match this function call with the signature of the second version, and call the appropriate version.

Many of the built-in C++ commands are overloaded, meaning that there are different versions that have different numbers and types of paramenters.

Although overloading is a useful feature, it should be used with caution. You might get yourself nicely confused if you are trying to debug one version of a function while accidently calling a different one.

Actually, this is a good time to mention one of the cardinal rules of debugging: make sure that the version of the program you are looking at is the version of the program that is running! Some time you may find yourself making one change after another in your program, and seeing the same thing every time you run it. This is a warning sign that for one reason or another you are not running the version of the program you think you are. To check, stick in an output statement (it doesn’t matter what it says) and make sure the behavior of the program changes accordingly.

5.5. Boolean functions

Functions can return bool values just like any other type. These functions are not surprisingly refered to as boolean functions, and they are often useful for hiding complicated tests inside functions. For example:

bool is_single_digit(int d)
{
    if (d >= 0 && d < 10) {
        return true;
    } else {
        return false;
    }
}

The name of this function is is_single_digit. It is common to give boolean functions names that sound like yes/no questions. The return type is bool, which means that every return statement has to provide a boolean expression.

The code itself is straightforward, although it is a bit longer than it needs to be. Remember that the expression d >= 0 && d < 10 has type bool, so there is nothing wrong with returning it directly, and avoiding the if statement altogether:

bool is_single_digit(int d)
{
    return (d >= 0 && d < 10);
}

In main you can call this function in the usual ways:

cout << is_single_digit(2) << endl;
bool bigFlag = !is_single_digit(17);

The first line outputs the value true because 2 is a single-digit number. Unfortunately, when C++ outputs bools, it does not display the words true and false, but rather the integers 1 and 0 (there is a way to that using the boolalpha flag, if you’re interested, but we won’t do that here). The second line assigns the value true to bigFlag only if 17 is not a single digit number.

The most common use of boolean functions is inside conditional statements:

if (is_single_digit(n)) {
    cout << "n is little" << endl;
} else {
    cout << "n is big" << endl;
}

5.6. Returning from main

Now that we have functions that return values, we can let you in on a secret. We have been returning 0 from our main function since our first C++ program. The reason is that 0 indicates that our program successfully finished whatever it was supposed to do. If something goes wrong, it is common to return a -1, or some other value that indicates what kind of error occured.

Of course, you might wonder who this value is returned to, since we never call main ourselves. It turns out that when the operating system executes a program, it starts by calling main in pretty much the same way it calls all the other functions.

There are even some parameters that are passed to main by the system, but we are not going to deal with them yet.

5.7. More recursion

So far we have only learned a small subset of C++, but you might be interested to know that this subset is now a complete programming language, by which we mean that anything that can be computed can be expressed in this language. Any program ever written could be rewritten using only the language features we have used so far (actually, we would need a few commands to control devices like the keyboard, mouse, disks, etc., but that’s all).

Proving this claim is a non-trivial exercise first accomplished by Alan Turing, one of the first computer scientists (well, some would argue that he was a mathematician, but a lot of early computer scientists started as mathematians). Accordingly, it is known as the Turing thesis. If you take a course on the theory of computation, you will have a chance to see the proof.

To give you an idea of what you can do with the tools we have learned so far, we’ll evaluate a few recursively-defined mathematical functions. A recursive definition is similar to a circular definition, in the sense that the definition contains a reference to the thing being defined. A truly circular definition is typically not very useful:

fabjuous: an adjective used to describe something that is frabjuous.

If you saw that definition in the dictionary, you’d be justified in being annoyed. On the other hand, if you look up the definition fo the mathematical function factorial, you will get something like:

\[\begin{split}0! &= 1\\ n! &= n\cdot(n-1)!\end{split}\]

(Factorial is usually denoted with the symbol !, which is not to be confused with the C++ operator ! which means NOT). This definition says that the factorial of 0 is 1, and the factorial of any other value, n, is n multiplied by the factorial of n - 1. So 3! is 3 times 2!, which is 2 times 1!, which is 1 times 0!. Putting it all together, we get 3! equal to 3 times 2 times 1 times 1, which is 6.

If you can write a recursive definition of something, you can usually write a C++ program to evaluate it. The first step is to decide what the parameters are for the function, and what the return type is. With a little thought, you should conclude that factorial takes an integer as an argument and returns an integer:

int factorial(int n)
{
}

If the argument happens to be zero, all we have to do is return 1:

int factorial(int n)
{
    if (n == 0) {
        return 1;
    }
}

Otherwise, and this is the interesting part, we have to make a recursive call to find the factorial of n - 1, and then multiply it by n.

int factorial(int n)
{
    if (n == 0) {
        return 1;
    } else {
        int recurse = factorial(n-1);
        int result = n * recurse;
        return result;
    }
}

If we look at the flow of execution for this program, it is similar to n_lines from the previous chapter. If we call factorial with value 3:

Since 3 is not zero, we take the second branch and calculate the factorial of n - 1…

Since 2 is not zero, we take the second branch and calculate the factorial of n - 1…

Since 1 is not zero, we take the second branch and calculate the factorial of n - 1…

Since 0 is zero, we take the first branch and return the value 1 immediately without making any more recursive calls.

The return value (1) gets multiplied by n, which is 1, and the result, 1, is returned.

The return value (1) gets multiplied by n, which is 2, and the result, 2, is returned.

The return value (2) gets multiplied by n, which is 3, and the result, 6, is returned to main, or whoever called factorial(3).

Here is what the stack diagram looks like for this sequence of function calls:

The return values are shown being passed back up the stack.

Notice that in the last instance of factorial, the local variables recurse and result do not exist because when n=0 the branch that creates them does not execute.

5.8. Leap of faith

Following the flow of execution is one way to read programs, but as you saw in the prevous section, it can quickly become labarynthine. An alternative is what we call the “leap of faith.” When you come to a function call, instead of following the flow of execution, you assume that the function works correctly and returns the appropriate value.

In fact, you are already practicing this leap of faith when you use built-in functions. When you call cos or exp, you don’t examine the implementations of those functions. You just assume that they work, because the people who wrote the built-in libraries were good programmers.

Well, the same is true when you call one of your own functions. For example, in Boolean functions we wrote a function called is_single_digit that determines whether a number is between 0 and 9. Once we have convinced ourselves that the function is correct - by testing and examination of the code - we can use the function without ever looking at the code again.

The same is true of recursive programs. When you get to the recursive call, instead of following the flow of execution, you should assume that the recursive call works (yields the correct result), and then ask yourself, “Assuming that I can find the factorial of n - 1, can I compute the factorial of n?” In this case, it is clear that you can by multiplying by n.

Of course, it is a bit strange to assume that the function works correctly when you have not even finished writing it, but that’s why it’s called a leap of faith!

5.9. One more example

In the previous example we used temporary variables to spell out the steps, and to make the code easier to debug, but we could have saved a few lines:

int factorial(int n)
{
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n-1);
    }
}

From now on we will tend to use the more concise version, but we recommend that you use the more explicit version while you are developing the code. When you have it working, you can tighten it up, if you are feeling inspired.

After factorial, the classic example of a recursely-defined mathematical function is the one that generates number in the fibonacci sequence, which has the following definition:

\[\begin{split}fibonacci(0) &= 1\\ fibonacci(1) &= 1\\ fibonacci(n) &= fibonacci(n-1) + fibonacci(n-2)\end{split}\]

Translated into C++, this is

int fibonacci(int n)
{
    if (n == 0 || n == 1) {
        return 1;
    }
    return fibonacci(n-1) + fibonacci(n-2);
}

If you try to follow the flow of execution here, even for fairly small values of n, your head explodes. But according to the leap of faith, if we assume that the two recursive calls (yes, you can make two recursive calls) work correctly, then it is clear that we get the right result by adding them together.

5.10. Glossary

dead code

Part of a program that can never be executed, often because it appears after a return statement.

function signature

The function name together with the number and types of parameters. The signature determines which overloaded function is called.

overloading

Having more than one function with the same name but different parameter types. When you call an overloaded function, C++ knows which version to use by looking at the types of the arguments you provide.

return type

The type a value a function sends back to the caller (returns).

return value

The value sent to the caller of a function (returned by the function).

scaffolding

Code that is used during program development but is not part of the final version.

void

A special return type that indicates a void function; that is, one that does not return a value.

5.11. Exercises

• Chapter 5 Exercise Set 0: Chapter Review

• Chapter 5 Exercise Set 1: CPE Practice

• Chapter 5 Exercise Set 2: Introducing doctest