A program in C consists of one or more functions, one of them must be called the main, the controlling function. The program execution always begins by executing the main function. Additional function definitions may precede or follow main.
A function description consists of the following components :
1. A function heading, which consists of the function name, followed by an optional list of arguments enclosed in parentheses.
2. A list of argument declaration, if arguments are included in the heading.
3. A compound statement, which comprises the remainder of the function.
The arguments are symbols that represent information being passed between the function and other parts of the program. (Arguments are also referred to as parameters.)
Each compound statement is enclosed within a pair of braces, i.e., { }. The braces may contain combinations of elementary statements (called expression statements) and other compound statements. Thus, compound statements may be nested, one within another. Each expression statement must end with a semicolon (;). Comments remarks) may appear anywhere within a program, as long as they are placed within the delimiters /* and */ (e.g., /* this is a comment */). Such comments are useful for identifying the principal features of the program and also for explaining the underlying logic.
Consider the flow-chart in fig 1.1 depicting how the roots of a quadratic polynomial can be found.
Example 1.1 :
Based on this flowchart, a sample C program for finding the real roots of a quadratic polynomial is given below:
# include
# include
/*program to find the real roots of a quadratic polynomial */
main()
{
/* type declaration of the variable*/
float a, b, c, discriminant, d, w, root1, root2;
/*function declaration*/
float compute_discriminant(float x,float y,float z);
printf(“Give the values of the coefficients a,b,c of the polynomial :”);
scanf(“%f %f %f”,&a,&b,&c);
fflush(stdin); /* flushing the buffer associated with standard input*/
discriminant=compute_discriminant(a,b,c);/*invoking a function */
d= 2 * a;
if(discriminant == 0)
printf(“The roots are equal - %f\n”,- b / d);
else
if(discriminant <>
printf(“The roots are complex\n”);
else
{
w=sqrt(discriminant);
printf(“The roots are real and different\n”);
root1=(-b - w) / d;
root2=(-b + w) / d;
printf(“Root1 = %f, Root2 = %f\n”,root1,root2);
}
}
/* Function definition */
float compute_discriminant(floatx, float y, float z)
{
float d; /*local variable declaration*/
d=y * y - 4 * x * z;
return d;
}
Here the main function utilises a separate programmer defined function called compute_discriminant, to find the value of the discriminant. Within the programmer defined function, x, y, z are arguments (also called as parameter). The values for these parameters are supplied from the main. The values of a, b, c are supplied to x, y, z respectively. Then the programmer defined function performs the calculations and the result is returned to the main.
This function is called in the main in the statement :
discriminant=compute_discriminant(a,b,c);
The above statement invokes the function compute_discriminant with arguments a, b and c. The function main transfers the control of the program execution to another function (compute_discriminant). The called function finally returns the control back to the calling function (in this case main) with the result of the calculation performed by it.
The main function also includes a function declaration, which indicates that compute_discriminant accepts floating-point arguments and returns a floating-point value.
