Answer:
function is a self-contained program segment that carries out some specific, well-defined task. Every C program consists of one or more functions. One of these functions must be called main. Execution of the program always begins by carrying out the instructions contained in main. Note that if a program contains multiple functions then their definitions may appear in any order. The same function can be accessed from several different places within a program. Once the function has carried out its intended action, control is returned to the point from which the function was accessed. Generally speaking, a function processes information passed to it from the calling portion of the program, and returns a single value. Some functions, however, accept information but do not return anything.
A function definition has two principal components: the first line (including the argument declarations), and the so-called body of the function.
The first line of a function takes the general form data-type name(type 1 arg 1, type 2 arg 2, ..., type n arg n)
where data-type represents the data type of the item that is returned by the function, name represents the name of the function, and type 1, type 2, ..., type n represent the data types of the arguments arg 1, arg 2, ..., arg n. The allowable data types for a function are:
int for a function which returns an integer value
double for a function which returns an floating-point value
void for a function which does not return any value
The allowable data types for a function's arguments are int and double. Note that the identifiers used to reference the arguments of a function are local, in the sense that they are not recognized outside of the function. Thus, the argument names in a function definition need not be the same as those used in the segments of the program from which the function was called. However, the corresponding data types of the arguments must always match.
The body of a function is a compound statement that defines the action to be taken by the function. Like a regular compound statement, the body can contain expression statements, control statements, other compound statements, etc. The body can even access other functions. In fact, it can even access itself--this process is known as recursion. In addition, however, the body must include one or more return statements in order to return a value to the calling portion of the program.
A return statement causes the program logic to return to the point in the program from which the function was accessed. The general form of a return statement is:
return expression;
This statement causes the value of expression to be returned to the calling part of the program. Of course, the data type of expression should match the declared data type of the function. For a void function, which does not return any value, the appropriate return statement is simply:
return;
A maximum of one expression can be included in a return statement. Thus, a function can return a maximum of one value to the calling part of the program. However, a function definition can include multiple return statements, each containing a different expression, which are conditionally executed, depending on the program logic.
Note that, by convention, the main function is of type int and returns the integer value 0 to the operating system, indicating the error-free termination of the program. In its simplest form, the main function possesses no arguments. The library function call exit(1), employed in previous example programs, causes the execution of a program to abort, returning the integer value 1 to the operating system, which (by convention) indicates that the program terminated with an error status.
The program segment listed below shows how the previous program factorial.c can be converted into a function factorial(n) which returns the factorial (in the form of a floating-point number) of the non-negative integer n:
double factorial(int n)
{
/*
Function to evaluate factorial (in floating-point form)
of non-negative integer n.
*/
int count;
double fact = 1.;
/* Abort if n is negative integer */
if (n < 0)
{
printf("\nError: factorial of negative integer not defined\n");
exit(1);
}
/* Calculate factorial */
for (count = n; count > 0; --count) fact *= (double) count;
/* Return value of factorial */
return fact;
}
Explanation: