C++ Primer Plus

A function terminates after executing a return statement. If a function has more than one return statement—for example, as alternatives to different if else selections—the function terminates after it executes the first return statement it reaches. For instance, in the following example, the else isn’t needed, but it does help the casual reader understand the intent:

int bigger(int a, int b)

{

    if (a > b )

        return a;  // if a > b, function terminates here

    else

        return b;  // otherwise, function terminates here

}

(Usually, having multiple return statements in a function is considered potentially confusing, and some compilers might issue a warning. However, the code here is simple enough to understand.)

Functions with return values are much like functions in Pascal, FORTRAN, and BASIC. They return a value to the calling program, which can then assign that value to a variable, display the value, or otherwise use it. Here’s a simple example that returns the cube of a type double value:

double cube(double x)    // x times x times x

{

    return x * x * x; // a type double value

}

For example, the function call cube(1.2) returns the value 1.728. Note that this return statement uses an expression. The function computes the value of the expression (1.728, in this case) and returns the value.

Prototyping and Calling a Function

By now you are familiar with making function calls, but you may be less comfortable with function prototyping because that’s often been hidden in the include files. Listing 7.2 shows the cheers() and cube() functions used in a program; notice the function prototypes.

Listing 7.2. protos.cpp

// protos.cpp -- using prototypes and function calls

#include

void cheers(int);       // prototype: no return value

double cube(double x);  // prototype: returns a double

int main()

{

    using namespace std;

    cheers(5);          // function call

    cout << "Give me a number: ";

    double side;

    cin >> side;

    double volume = cube(side);    // function call

    cout << "A " << side <<"-foot cube has a volume of ";

    cout << volume << " cubic feet.\n";

    cheers(cube(2));    // prototype protection at work

    return 0;

}

void cheers(int n)

{

    using namespace std;

    for (int i = 0; i < n; i++)

        cout << "Cheers! ";

    cout << endl;

}

double cube(double x)

{

    return x * x * x;

}

The program in Listing 7.2 places a using directive in only those functions that use the members of the std namespace. Here’s a sample run:

Cheers! Cheers! Cheers! Cheers! Cheers!

Give me a number: 5

A 5-foot cube has a volume of 125 cubic feet.

Cheers! Cheers! Cheers! Cheers! Cheers! Cheers! Cheers! Cheers!

Note that main() calls the type void function cheers() by using the function name and arguments followed by a semicolon: cheers(5);. This is an example of a function call statement. But because cube() has a return value, main() can use it as part of an assignment statement:

double volume = cube(side);

But I said earlier that you should concentrate on the prototypes. What should you know about prototypes? First, you should understand why C++ requires prototypes. Then because C++ requires prototypes, you should know the proper syntax. Finally, you should appreciate what the prototype does for you. Let’s look at these points in turn, using Listing 7.2 as a basis for discussion.

Why Prototypes?

A prototype describes the function interface to the compiler. That is, it tells the compiler what type of return value, if any, the function has, and it tells the compiler the number and type of function arguments. Consider how the prototype affects this function call from Listing 7.2:

double volume = cube(side);

First, the prototype tells the compiler that cube() should have one type double argument. If the program fails to provide the argument, prototyping allows the compiler to catch the error. Second, when the cube() function finishes its calculation, it places its return value at some specified location—perhaps in a CPU register, perhaps in memory. Then the calling function, main() in this case, retrieves the value from that location. Because the prototype states that cube() is type double, the compiler knows how many bytes to retrieve and how to interpret them. Without that information, the compiler could only guess, and that is something compilers won’t do.