Example of a Function in C - How to create a function in C

Some examples of modular programming in C:

Example: Design a modular program to add two numbers

 

#include<stdio.h>

/* prototype */

int add (int x, int y);

 

int main()

{   int a, b, c;

    a = 10;  b = 20,;

    c = add (a, b);    /* function call */

    printf(“\n The sum is : %d”, c);

    return 0;

}

 

/* function to add two integers

   Input  :  two integer x and y

   Output :  sum of x and y

*/

int add (int x, int y)

{   z = x + y;

    return (z);

}

 

NOTE

          i.          Prototype means the behavior of the function, i.e.

o   the return type,            

o   the name and,        

o   the number and type of input parameter

There is no need of identifiers in the prototype. So, the following is also sufficient

 

      int  add (int,  int );

 

The prototype is also called “declaration”   or   “header” .

 

         ii.         The body of a function that contains actual code for the function is called “definition”.

        iii.        The definition of a function can also be given before main() function. In this case there  is no need of prototype.

         iv.        The function main is the “calling function”,  and   add() is  “called function”.

          v.         In the calling function, there is function call statement. The list inside parentheses is called “argument list”.

         vi.        In the header of the called function, the list inside the parentheses is called the “parameter list”.

        vii.       The type and number of arguments must exactly match with those parameter.

       viii.      The value of arguments is assigned to corresponding parameters.

 

c = add (a,     b);                      / * call  *

int  add ( int  x,  int  y )           /* header of definition  */
Effectively, it is an assignment operation:     x = a;   y = b;

 

 

 

The identifiers a, b and c are called local identifier s of function main(). The identifiers x, y and z are called local identifier of add() function.  A local identifier can be used within the function in which it is declared. So a, b and c are accessible within main() only. Similarly x, y and z are accessible within add() function only.

 

         ix.        A function can contain more than one return physically. But, logically only one will be executed out of them. As soon as a return in the called function encounters, execution control is transferred to the calling function at the point where a function call was made.
                        c = add (a, b);

Effectively, the returned value is assigned to the lvalue of the assignment statement of the function call. So, the equivalent effect is:          

c = z

          x.         The data type of a following three must exactly match:
· The data type of return expression in called function.
· The return type of the function.
· The data type of variable, in which the returned value is being stored.

      xi.          The returned value can be discarded, if not required.

     xii.         If the function does not return anything, its return type is void. A void function may or may have not return statement. If there is no return statement, it is implicitly inserted at the end of function.

    xiii.        Guideline: Normally, a function should not contain input/output statement, because it looses the generality of function. the input to the function should be supplied as parameter. The result is normally returned from the function. but this scheme has limitation, that we can return only single value from the function multiple returned values can be done with the help of:

·         Structures

·         call by reference parameter.

 

 

Example

/* program to find factorial of a number */

#include<stdio.h>

long factorial(int);   /* prototype */

int main()

{   int n;

    long fact;

    printf(“\nEnter a number : “);

    scanf(“%d”, &n);

    fact = factorial(n);

    printf(“\n The factorial is : %ld”, fact);

    return 0;

}

/* function to find factorial

   Input    :  a number n

  Output  :  factorial of n

*/

long factorial (int num)

{   long fact = 1;

    /* loop to calculate factorial  */

    for (int I = 2; i<= num;  ++i)

     fact *= I;

    return fact;

}

 

Formation of Stack:

The operating system maintains a user stack to keep track of functions called. When a function is called, a new entry on the top of stack is inserted, this entry contain the local identifiers of the called function. When the function ends, this entry is popped (removed). The behavior of function matches with property of STACK. The function that is called at last will be completed first.

 

Example: Design a function that takes and integer as parameter and returns its factorial.

Note: Local variables in two different functions may be of same name, they are treated as independent variables. For example the variable ”fact” is local variable in the function main() and factorial() both. Both are entirely different. So, the values will not conflict. It is simply because separate space is allocated for “fact” of main() and “fact” of factorial().