** **

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 /* a preprocessor directive to include the file stdio.h */*

*# 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 (

**). The called function finally returns the control back to the calling function (in this case**

*compute_discriminant**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.