5. Should a function contain a return statement if it does not return a value?
In C, void functions (those that do not return a value to the calling function) are not required to include a return statement. Therefore, it is not necessary to include a return statement in your functions declared as being void.
your function might trigger some critical error, and an immediate exit from the function might be necessary. In this case, it is perfectly acceptable to use a return statement to bypass the rest of the function’s code. However, keep in mind that it is not considered good programming practice to litter your functions with return statements-generally, you should keep your function’s exit point as focused and clean as possible.
6. How can you pass an array to a function by value?
An array can be passed to a function by value by declaring in the called function the array name with square brackets ([ and ]) attached to the end. When calling the function, simply pass the address of the array (that is, the array’s name) to the called function. For instance, the following program passes the array x[] to the function named byval_func() by value:
#include <stdio.h>
void
byval_func(
int
[]);
/* the byval_func() function is passed an
integer array by value */
void
main(
void
);
void
main(
void
)
{
int
x[
10
];
int
y;
/* Set up the integer array. */
for
(y=
0
; y<
10
; y++)
x[y] = y;
/* Call byval_func(), passing the x array by value. */
byval_func(x);
}
/* The byval_function receives an integer array by value. */
void
byval_func(
int
i[])
{
int
y;
/* Print the contents of the integer array. */
for
(y=
0
; y<
10
; y++)
printf(
“%d\n”
, i[y]);
}
In this example program, an integer array named x is defined and initialized with 10 values. The functionbyval_func() is declared as follows:
int byval_func(int[]);
The int[] parameter tells the compiler that the byval_func() function will take one argument—an array of integers. When the byval_func() function is called, you pass the address of the array to byval_func():byval_func(x);
Because the array is being passed by value, an exact copy of the array is made and placed on the stack. The called function then receives this copy of the array and can print it. Because the array passed to byval_func()is a copy of the original array, modifying the array within the byval_func() function has no effect on the original array.
Consider the following program, which passes the same array (x) to a function:
#include <stdio.h>
void
const_func(
const
int
*);
void
main(
void
);
void
main(
void
)
{
int
x[
10
];
int
y;
/* Set up the integer array. */
for
(y=
0
; y<
10
; y++)
x[y] = y;
/* Call const_func(), passing the x array by reference. */
const_func(x);
}
/* The const_function receives an integer array by reference.
Notice that the pointer is declared as const, which renders
it unmodifiable by the const_func() function. */
void
const_func(
const
int
* i)
{
int
y;
/* Print the contents of the integer array. */
for
(y=
0
; y<
10
; y++)
printf(
“%d\n”
, *(i+y));
}
In the preceding example program, an integer array named x is defined and initialized with 10 values. Thefunction const_func() is declared as follows:
int const_func(const int*);
The const int* parameter tells the compiler that the const_func() function will take one argument—a constant pointer to an integer. When the const_func() function is called, you pass the address of the array toconst_func():
const_func(x);
Because the array is being passed by reference, no copy of the array is made and placed on the stack. The called function receives simply a constant pointer to an integer. The called function must be coded to be smart enough to know that what it is really receiving is a constant pointer to an array of integers. The const modifier is used to prevent the const_func() from accidentally modifying any elements of the original array.
7. Is it possible to execute code even after the program exits the main() function?
The standard C library provides a function named atexit() that can be used to perform “cleanup” operations when your program terminates. You can set up a set of functions you want to perform automatically when your program exits by passing function pointers to the atexit() function. Here’s an example of a program that uses the atexit() function:
#include <stdio.h>
#include <stdlib.h>
void
close_files(
void
);
void
print_registration_message(
void
);
int
main(
int
,
char
**);
int
main(
int
argc,
char
** argv)
{
…
atexit(print_registration_message);
atexit(close_files);
while
(rec_count < max_records)
{
process_one_record();
}
exit(
0
);
}
This example program uses the atexit() function to signify that the close_files() function and theprint_registration_message() function need to be called automatically when the program exits. When themain() function ends, these two functions will be called to close the files and print the registration message. There are two things that should be noted regarding the atexit() function. First, the functions you specify to execute at program termination must be declared as void functions that take no parameters. Second, the functions you designate with the atexit() function are stacked in the order in which they are called withatexit(), and therefore they are executed in a last-in, first-out (LIFO) method. Keep this information in mind when using the atexit() function. In the preceding example, the atexit() function is stacked as shown here:
atexit(print_registration_message);
atexit(close_files);
Because the LIFO method is used, the close_files() function will be called first, and then theprint_registration_message() function will be called.
The atexit() function can come in handy when you want to ensure that certain functions (such as closing your program’s data files) are performed before your program terminates.
8. What does a function declared as PASCAL do differently?
A C function declared as PASCAL uses a different calling convention than a “regular” C function. Normally, C function parameters are passed right to left; with the PASCAL calling convention, the parameters are passed left to right.
Consider the following function, which is declared normally in a C program:
int regular_func(int, char*, long);
Using the standard C calling convention, the parameters are pushed on the stack from right to left. This means that when the regular_func() function is called in C, the stack will contain the following parameters:
long
char*
int
The function calling regular_func() is responsible for restoring the stack when regular_func() returns.
When the PASCAL calling convention is being used, the parameters are pushed on the stack from left to right.
Consider the following function, which is declared as using the PASCAL calling convention:
int PASCAL pascal_func(int, char*, long);
When the function pascal_func() is called in C, the stack will contain the following parameters:
int
char*
long
The function being called is responsible for restoring the stack pointer. Why does this matter? Is there any benefit to using PASCAL functions?
Functions that use the PASCAL calling convention are more efficient than regular C functions—the function calls tend to be slightly faster. Microsoft Windows is an example of an operating environment that uses the PASCAL calling convention. The Windows SDK (Software Development Kit) contains hundreds of functions declared as PASCAL.
