Problem 10 - C++ How to Program

Question

Perform the task specified by each of the following statements: a) Write the function header for function zero that takes a long integer array parameter bigIntegers and does not return a value. b) Write the function prototype for the function in part (a). c) Write the function header for function add 1 AndSum that takes an integer array parameter oneTooSmall and returns an integer. d) Write the function prototype for the function described in part (c).

Step-by-Step Solution

Answer

a) void zero(long bigIntegers[]); b) void zero(long[]); c) int add1AndSum(int oneTooSmall[]); d) int add1AndSum(int[]);

Step 1: Writing the Function Header for zero

The function header should include the function name, return type, and parameters. Since the function does not return any value, the return type should be void. The parameter is an array of long integers, so the type should be specified as a long integer array.

Step 2: Writing the Function Prototype for zero

The function prototype is a declaration of the function that informs the compiler about the function name and its parameters, as well as its return type, without the function body. It's written usually in the global scope or at the top of a file where the function is used.

Step 3: Writing the Function Header for add1AndSum

The function header for add1AndSum should include the function name, return type, and parameters. This function returns an integer, so the return type is int. The parameter is an array of integers, which should be reflected in its type declaration.

Step 4: Writing the Function Prototype for add1AndSum

Similar to the previous prototype, the function prototype for add1AndSum should include the function's return type, name, and parameters, serving as a forward declaration.

Key Concepts

Function Header

In C++, the function header is the first part of a function definition, serving as a crucial element regarding the function's interface with the rest of the program. It includes essential information such as the function's name, the parameter types it expects, and the type of value it will return. When defining a function that takes an array as a parameter, like in exercise (a), the function header must reflect the array type accurately. For instance, for a function named zero that takes a long integer array named bigIntegers and does not return a value, the function header would be:

void zero(long bigIntegers[])

This clearly communicates to anyone reading the code that zero will perform operations on an array of long integers and that it does not return any value, specified by the keyword void. Notably, the square brackets denote that bigIntegers is an array, not a single long integer.

Array Parameters

Handling arrays in functions is an aspect students often stumble upon. When defining a function that receives an array parameter, the parameter's type declaration must reflect that it is indeed an array. Instead of specifying the size of the array inside the function header or prototype, square brackets are used after the array name to indicate its type. For instance, the function prototype in exercise (b) would look like:

void zero(long bigIntegers[]);

This indicates that the function accepts an array of long integers. It's important to understand that in the context of function parameters, an array is treated as a pointer to its first element. Therefore, when passing an array to a function, you are actually passing the address of its first element, and the called function can modify the array's contents directly.

Return Types

A function's return type specifies what type of data the function is expected to return to the calling function. It is an essential part of the function header, providing a clear expectation of the function's output. For example, in exercise (c), the function add1AndSum is expected to return an integer, indicating that after processing, the function concludes with an integer value. Hence, its function header is written as:

int add1AndSum(int oneTooSmall[])

The presence of int before the function name signifies that upon completion, add1AndSum will return an integer value. The choice of return type should align with what the function's purpose is—whether performing a calculation, making a decision, or, as in the case of zero, performing an action without any direct output, which uses the return type void.

Function Prototype Declaration

The purpose of a function prototype declaration is to inform the compiler about a function's existence before its actual definition in the code. It is a contract that specifies the return type, the function name, and parameters without including the function's body. One of its practical uses appears in large programs or multi-file projects, allowing functions to be used before they're defined. Referring back to exercise (d), the function prototype for add1AndSum would look like this:

int add1AndSum(int oneTooSmall[]);

This is placed at the beginning of the file or in a header file to declare the function's presence, so it can be called from different parts of a program. A properly constructed prototype ensures the correct usage of the function and prevents errors related to incorrect function calls, facilitating smoother development and maintenance of complex codebases.