A function that has a return value produces a value that you can assign to a variable or use in some other expression. For example, the standard C/C++ library includes a function called sqrt()
that returns the square root of a number. Suppose you want to calculate the square root of 6.25 and assign it to the variable x
. You can use the following statement in your program:
x = sqrt(6.25); // returns the value 2.5 and assigns it to x
The expression sqrt(6.25)
invokes, or calls, the sqrt()
function. The expression sqrt(6.25)
is termed a function call, the invoked function is termed the called function, and the function containing the function call is termed the calling function (see Figure 2.6).
The value in the parentheses (6.25, in this example) is information that is sent to the function; it is said to be passed to the function. A value that is sent to a function this way is called an argument or parameter (see Figure 2.7). The sqrt()
function calculates the answer to be 2.5 and sends that value back to the calling function; the value sent back is termed the return value of the function. Think of the return value as what is substituted for the function call in the statement after the function finishes its job. Thus, this example assigns the return value to the variable x
. In short, an argument is information sent to the function, and the return value is a value sent back from the function.
That’s practically all there is to it, except that before the C++ compiler uses a function, it must know what kind of arguments the function uses and what kind of return value it has. That is, does the function return an integer? a character? a number with a decimal fraction? a guilty verdict? or something else? If it lacks this information, the compiler won’t know how to interpret the return value. The C++ way to convey this information is to use a function prototype statement.
A function prototype does for functions what a variable declaration does for variables: It tells what types are involved. For example, the C++ library defines the sqrt()
function to take a number with (potentially) a fractional part (like 6.25) as an argument and to return a number of the same type. Some languages refer to such numbers as real numbers, but the name C++ uses for this type is double
. (You’ll see more of double
in Chapter 3.) The function prototype for sqrt()
looks like this:
double sqrt(double); // function prototype
The initial double
means sqrt()
returns a type double
value. The double
in the parentheses means sqrt()
requires a double
argument. So this prototype describes sqrt()
exactly as used in the following code:
double x; // declare x as a type double variable
x = sqrt(6.25);
The terminating semicolon in the prototype identifies it as a statement and thus makes it a prototype instead of a function header. If you omit the semicolon, the compiler interprets the line as a function header and expects you to follow it with a function body that defines the function.
When you use sqrt()
in a program, you must also provide the prototype. You can do this in either of two ways:
• You can type the function prototype into your source code file yourself.
• You can include the cmath
(math.h
on older systems) header file, which has the prototype in it.
The second way is better because the header file is even more likely than you to get the prototype right. Every function in the C++ library has a prototype in one or more header files. Just check the function description in your manual or with online help, if you have it, and the description tells you which header file to use. For example, the description of the sqrt()
function should tell you to use the cmath
header file. (Again, you might have to use the older math.h
header file, which works for both C and C++ programs.)
Don’t confuse the function prototype with the function definition. The prototype, as you’ve seen, only describes the function interface. That is, it describes the information sent to the function and the information sent back. The definition, however, includes the code for the function’s workings—for example, the code for calculating the square root of a number. C and C++ divide these two features—prototype and definition—for library functions. The library files contain the compiled code for the functions, whereas the header files contain the prototypes.
You should place a function prototype ahead of where you first use the function. The usual practice is to place prototypes just before the definition of the main()
function. Listing 2.4 demonstrates the use of the library function sqrt()
; it provides a prototype by including the cmath
file.
// sqrt.cpp -- using the sqrt() function
#include <iostream>
#include <cmath> // or math.h
int main()
{
using namespace std;
double area;
cout << "Enter the floor area, in square feet, of your home: ";
cin >> area;
double side;
side = sqrt(area);
cout << "That's the equivalent of a square " << side
<< " feet to the side." << endl;
cout << "How fascinating!" << endl;
return 0;
}
Here’s a sample run of the program in Listing 2.4:
Enter the floor area, in square feet, of your home: 1536
That's the equivalent of a square 39.1918 feet to the side.
How fascinating!
Because sqrt()
works with type double
values, the example makes the variables that type. Note that you declare a type double
variable by using the same form, or syntax, as when you declare a type int
variable:
type-name variable-name;
Type double
allows the variables area
and side
to hold values with decimal fractions, such as 1536.0
and 39.1918
. An apparent integer, such as 1536
, is stored as a real value with a decimal fraction part of .0
when stored in a type double
variable. As you’ll see in Chapter 3, type double
encompasses a much greater range of values than type int
.
C++ allows you to declare new variables anywhere in a program, so sqrt.cpp
didn’t declare side
until just before using it. C++ also allows you to assign a value to a variable when you create it, so you could also have done this:
double side = sqrt(area);
You’ll learn more about this process, called initialization, in Chapter 3.
Note that cin
knows how to convert information from the input stream to type double
, and cout
knows how to insert type double
into the output stream. As noted earlier, these objects are smart.
18.225.95.245