Before a function is called in a program, the system should know where to look for the function definition. In case of functions belonging to C standard library we include the relevant header files in which the function is defined. This is done above the main() function. In case of user-defined functions, a function may be defined above or below the main function, because, a function cannot be defined inside another function. If a function is defined above the main function, there is no need of a separate declaration of function. However, if the function is defined below the main function, it is a good programming practice to declare the functions being used above the main. A function declaration may be done by the function header or by its prototype.
If a function call precedes its definition in a program, we should declare the function before the call. A function declaration takes the following general form:
ret_ type func_ name ( param_type_list ) ;
For example, the prototypes of the three functions Area_rect, Area_ circle and Display may be written as.
int Area_rect(int, int);
double Area_circle( float);
void Display ();
where func _name is the name of the function, ret_type is the type of the return value and param_type_list is a comma-separated list of function parameter types. Note that this format is similar to the function definition except that the parameter declaration list is replaced by the parameter type list and the function body is replaced by a semicolon. Also note that formal parameter names may be included in a function declaration and are treated as comments. They may be replaced with other names as well. Thus, to include a function declaration in a program, we can simply copy the first line of the function definition (and insert a semicolon after it).
Function declarations are usually written at the beginning of a program, before the main function. Such declarations outside any function are called global declarations. A function may also be declared within the function from which it is called. The problem with such a local declaration is that its scope is restricted to the function in which it is declared, i. e., it is available only within that function. Thus, if this locally declared function is also called from some other function, we must provide its declaration in that function as well.
Although a program can contain only one definition of a function, there is no restriction on the number of declarations. A function may be declared more than once within the same scope. However, note that each declaration must be consistent with its definition with regard to the number of parameters, their types and the return type.
A function declaration provides valuable information (function name, number and type of parameters and return type) to the compiler. The compiler uses this information to ensure that the function call is consistent with its definition. Thus, the compiler can check that the number of arguments in a function call and the types of arguments are as per the requirements of the function and that the function call is consistent with respect to the type of the value returned by the function. The compiler can report errors or warnings when a function call is not consistent with its definition. Note that if a function definition precedes its calls, the compiler obtains the necessary information from the function definition itself thereby eliminating the need for a function declaration. However, this is not good programming practice.
If the type of an argument in a function call is different from the type of the corresponding parameter in function definition, automatic conversion is applied if possible, to convert the argument to the type of the parameter. If automatic conversion is not possible, the compiler will report an error. Also note that if a function declaration or definition is not available to a compiler before the function call is encountered, the compiler can neither perform such automatic conversions nor it can report any errors if such conversions are not possible. The compiler may, however, give a warning that a function call is encountered without a function prototype. The compiler assumes that this function returns a value of type int. Thus, if the function actually returns a different type of value, the compiler can report an error or warning.
Illustrates the declaration of prototypes
float Volume(float,float,float); //function prototype
float Surface_area (float,float,float); //function prototype
float x,y,z, V, S ;
printf("Write three dimensions of a cubical object: ");
scanf ("%f%f%f",&x, &y, &z);
V = Volume(x,y,z);
S = Surface_area(x,y,z);
printf("Volume = %f,\t Surface area= %f\n", V, S);
float Volume ( float a,float b,float c) /*function definition*/
float Surface_area( float a, float b, float c) //Definition
return 2*( a*b +b*c+c*a);
The expected output of the above program is written as follows: