C++ Chapter 4: Procedural Abstraction & Functions That Return a Value

In other programming languages, subparts such as subprograms, procedures, or methods, C++ calls these parts:

The value the function starts out with is called its

The expression sqrt(9) is called a

An expression consisting of the function name followed by arguments enclosed in parentheses is a:

The name inside the angular brackets <> is the name of the file known as a:

A header file for a library provides the compiler with certain basic informatino about the library, and an include directive delivers this information to the compiler. This enables the linker to find object code for the functions in the library so that it can correctly link the library to your program.

A pseudorandom number is one that appears to be random but is really determined by a predictable formula.
R_{i =} (R_i-7 * 7) % 11

We can get a random number by calling the function rand, which will return an integer in the range 0 to RAND_MAX. RAND_MAX is a constant defined in cstdlib and is guaranteed to be 32767 or higher.

It is important to seed the random number generator only once.

The notation static_cast<double>(9) is called a type cast. This notation can be used as a predefined function and will convert a value of some other type to a value of type double.

You can define your own functions, either in the same file as the main part of your program or in a separate file so that the functions can be used by several different programs.

The function declaration or function prototype describes how the function is called. C++ requires that either the complete function definition or the function declaration appears in the code before the function is called.

A formal parameter is used as a kind of blank or place holder to stand in for the argument. Formal parameters names will end with _par.

The first word in a function declaration specifies the type of the value returned by the function.

The function call is the expression on the right-hand side of the equal sign:
bill = total_cost(number, price)

A function definition describes how the function computes the value it returns.

The function header is written the same way as the function declaration, except that the header does not have a semicolon at the end.

The function body follows the function header and completes the function definition. The function body consists of declarations and executable statements enclosed within a pair of braces.

The return statement consists of the keyword return followed by an expression:
return (subtotal + subtotal * TAX_RATE);

A function may return a bool value.

You are not required to list formal parameters in a function declaration.

Function headers must always list the formal parameter names.

Function declarations are normally placed before the main part of the program and function definitions are normally placed after the main part of the program.

A function definition may contain more than one return statement.

A programmer who uses a function in a program need to know what the function does but should not need to know how the function accomplishes its task. This is often referred to as treating the function like a black box.

Writing and using functions as if they were black boxes is called:

The variables that belong to a function are called:

Formal parameters are variables that are local to the function definition so they can be used just like a local variable that is declared in the function definition.

When a function is called, the formal parameters for the (which are local variables) are initialized to the values of the arguments.

The scope of a local variable refers to the part of the program that can directly access that variable and is sometimes referred to as:

The scope rule states that identifiers declared within their block are local to that block and accessible only from the point they are defined to the end fo their block.

When you give 2 or more function definitions for the same function name, that is called:

In order to tell which function definition to use, the compiler checks the number of arguments and the types of the arguments in the function call.

If a function requires an argument of type double and you give it an argument of type int, C++ will automatically convert the int argument to the value of type double.

C++ does not convert an int argument to a value of type double unless that is the only way it can find a matching function definition.

A good plan of attack for designing the algorithm for a program is to break down the task to be accomplished into a few subtasks, then decompose each subtask into smaller subtaks, and so forth until the subtask are simple enough that they can easily be implemented as C++ code. This approach is called top-down design.

A function that returns a value is like a small program. The arguments to the function serve as the input to this "small program" and the value returned is like the output of the "small program".

When a subtask for a program takes some values as input and produces a single value as its only result, then that subtask can be implemented as a function.

A function should be defined so that it can be used as a black box. The programmer who uses the function should not need to know any details about how the function is coded. All the programmer should need to know is the function declaration and the accompanying comment that describes the value returned. This rule is sometimes called the principle of procedural abstraction.

A variable that is declared in a function definition is said to be local to the function.

Global named constants are declared using the const modifier. Declarations for global named constants are normally placed at the start of the program after the include directive and before the function declarations.

Call-by-value formal parameters (which are the only kind of formal parameter discussed) are variables that are local to the function. Occasionally, it is useful to use a formal parameter as a local variable.

When you have 2 or more function definitions for the same function name, that is called overloading the function name. When you overload a function name, the function definitions must have different numbers of formal parameters or some formal parameters of different types.