Module No:04

Functions, Library functions and

Storage Classes
Summative Assessment weightage: 18 to 20 Mark
User‐Defined Functions
Definition: A function is a block of code/group of
statements/self contained block of statements/ basic building
blocks in a program that performs a particular task. It is also
known as procedure or subroutine or module, in other
programming languages.
To perform any task, we can create function. A function can be
called many times. It provides modularity and code reusability.
Advantage of functions
1) Code Reusability: By creating functions in C, you can call it many
times. So, we don't need to write the same code again and again.
2) Code optimization: It makes the code optimized we don't need to
write much code. 3
3) Easily to debug the program.
Example: Suppose, you have to check 3 numbers (781, 883 and 531)
whether it is prime number or not. Without using function, you need to
write the prime number logic 3 times. So, there is repetition of code.
But if you use functions, you need to write the logic only once and
you can reuse it several times.
Types of Functions
There are two types of functions in C programming:
1. Library Functions: are the functions which are declared in the C
header files such as
scanf(), printf(), gets(), puts(), ceil(), floor() etc. You just need to include
appropriate header files to use these functions. These are already
declared and defined in C libraries.
Points to be Remembered
System defined functions are declared in header files
System defined functions are implemented in .dll files. (DLL stands for
Dynamic Link Library).
To use system defined functions the respective header file must be
included.
2. User-defined functions:
User-defined functions: are the functions which are created by the C
programmer, so that he/she can use it many times. It reduces
complexity of a big program and optimizes the code. Depending upon
the complexity and requirement of the program, you can create as
many user-defined functions as you want.
ELEMENTS OF USER-DEFINED FUNCTINS :

In order to write an efficient user defined function, the

programmer must familiar with the following three
elements.
1 : Function Declaration. (Function Prototype).
2 : Function Call.
3 : Function Definition
Function Declaration. (Function Prototype).
A function declaration is the process of tells the compiler about a function
name.
Syntax
return_type function_name(parameter/argument);
return_type function-name();
Ex : int add(int a,int b);
int add();
Note: At the time of function declaration function must be terminated with ;.
 Calling a function/function call
When we call any function control goes to function body and execute entire
code.
Syntax : function-name();
function-name(parameter/argument);
return value/ variable = function-name(parameter/argument);

Ex : add(); // function without parameter/argument

add(a,b); // function with parameter/argument
c=fun(a,b); // function with parameter/argument and return values
Defining a function. Defining of function is nothing but give
body of function that means write logic inside function body.

Syntax
return_ type function-name(parameter list) // function header.
{
declaration of variables;
body of function; // Function body
return statement; (expression or value) //optional
}
Example of Defining a function

Eg: int add( int x, int y) int add( int x, int y)

{ {
int z; ( or ) return ( x + y );
z = x + y; }
return z;
}
The execution of a C program begins from the main()
function.
When the compiler encounters functionName(); inside
the main function, control of the program
jumps to
void functionName()
And, the compiler starts executing the codes inside the
user-defined function.
The control of the program jumps to statement next to
functionName(); once all the codes inside the function
definition are executed.
Example:
#include<stdio.h>
#include<conio.h>

void sum(); // declaring a function

clrsct();
int a=10,b=20, c;
void sum() // defining function
{
c=a+b;
printf("Sum: %d", c);
}
void main()
{
sum(); // calling function
}
Output
Sum:30
Example:
#include <stdio.h>
int addNumbers(int a, int b); // function prototype
int main()
{
int n1,n2,sum;
printf("Enters two numbers: ");
scanf("%d %d",&n1,&n2);
sum = addNumbers(n1, n2); // function call
printf("sum = %d",sum);
return 0;
}
int addNumbers(int a,int b) // function definition
{
int result;
result = a+b;
return result; // return statement
}
Syntax of return statement
Syntax : return; // does not return any value
or
return(exp); // the specified exp value to calling function.
For example,
return a;
return (a+b);
The return statement terminates the execution of a function and
returns a value to the calling function. The program control is
transferred to the calling function after return statement.
In the above example, the value of variable result is returned to the
variable sum in the main() function.
Global and local variables:
Local variable:
● It is generally declared inside a function.
● If it isn’t initialized, a garbage value is stored inside it.
● It is created when the function begins its execution.
● It is lost when the function is terminated.
Global variable:
• It is declared outside the function.
● If it isn’t initialized, the value of zero is stored in it as default.
● It is created before the global execution of the program.
● It is lost when the program terminates.
PARAMETERS : parameters provides the data communication
between the calling function and called function. They are two types of
parameters
1: Actual parameters.
2 : Formal parameters.
1 :Actual Parameters : These are the parameters transferred from the calling
function (main program) to the called function (function).
2 : Formal Parameters :These are the parameters transferred into the calling
function (main program) from the called function(function).
 The parameters specified in calling function are said to be Actual
Parameters.
 The parameters declared in called function are said to be Formal
Parameters.
 The value of actual parameters is always copied into formal parameters.
Ex : main()
{
fun1( a , b ); //Calling function
}
fun1( x, y ) //called function
{
..... .
}
Where
a, b are the Actual Parameters
x, y are the Formal Parameters
 Difference between Actual Parameters and Formal
Parameters
Actual Parameters Formal Parameters
1 : Actual parameters are used in calling function 1 : Formal parameters are used in the function
when a function is invoked. header of a called function.
Ex : c=add(a,b); Ex : int add(int m,int n);
Here a,b are actual parameters. Here m,n are called formal parameters.

2 : Actual parameters can be constants, 2 : Formal parametes should be only

variables or expression. variable. Expression and constants are not
Ex : c=add(a,b) //variable allowed.
c=add(a+5,b); //expression. Ex : int add(int m,n); //CORRECT
c=add(10,20); //constants. int add(int m+n,int n) //WRONG
int add(int m,10); //WRONG
3 : Actual parameters sends values to the 3 : Formal parametes receive values from
formal parameters. the actual parametes.
Ex : c=add(4,5); Ex : int add(int m,int n);
Here m will have the value 4 and n will
have the value 5.
PASSING PARAMETERS TO FUNCTIONS :There are two ways to pass
value or data to function in C language: call by value and call by reference.
Original value is not modified in call by value but it is modified in call by
reference.
The called function receives the information from the calling function through
the parameters.
The variables used while invoking the calling function are called actual
parameters and the
variables used in the function header of the called function are called formal
parameters.
C provides two mechanisms to pass parameters to a function.

1 : Pass by value (OR) Call by value.

2 : Pass by reference (OR) Call by Reference.
 1 : Pass by value (OR) Call by value :
In call by value, value being passed to the function is locally stored by the
function parameter in stack memory location. If you change the value of
function parameter, it is changed for the current function only. It will not
change the value of variable inside the caller method such as main().
Or
When a function is called with actual parameters, the values of actual
parameters are copied into formal parameters. If the values of the formal
parameters changes in the function, the values of the actual parameters
are not changed. This way of passing parameters is called pass by value or
call by value.
#include<stdio.h>
#include<conio.h>
void swap(int ,int );
void main()
{
int i,j;
printf("Enter i and j values:");
scanf("%d%d",&i,&j); OUTPUT:
printf("Before swapping:%d%d\n",i,j);
swap(i,j);
printf("After swapping:%d%d\n",i,j);
getch();
}
void swap(int a,int b)
{
int temp;
temp=a;
a=b;
b=temp;
}
2 : Pass by reference (OR) Call by Reference
In pass by reference, a function is called with addresses of actual
parameters. In the function header, the formal parameters receive the
addresses of actual parameters. Now the formal parameters do not
contain values, instead they contain addresses. Any variable if it
contains an address, it is called a pointer variable. Using pointer
variables, the values of the actual parameters can be changed. This way
of passing parameters is called call by reference or pass by reference.
Ex : #include<stdio.h>
#include<conio.h>
void swap(int *,int *);
void main()
{
int i,j;
printf("Enter i and j values:");
scanf("%d%d",&i,&j); OUTPUT
printf("Before swapping:%d%d\n",i,j);
swap(&i ,&j);
printf("After swapping:%d%d\n",i,j);
}
void swap(int *a,int *b)
{
int temp;
temp=*a;
*a=*b;
*b=temp; }
Difference between Call by value and Call by reference
The functions can be written in four different ways:
1: Functions with no Parameters and no Return Values.
2 : Functions with no Parameters and Return Values.
3 : Functions with Parameters and no Return Values.
4 : Functions with Parameters and Return Values.
1 : Functions with no Parameters and no Return Values :
1 : In this category, there is no data transfer between the calling
function and called function.
2 : But there is flow of control from calling function to the called
function.
3 : When no parameters are there , the function cannot receive any
value from the calling
function.
4: When the function does not return a value, the calling function
cannot receive any value from
the called function.
Ex
#include <stdio.h>
#include<conio.h>
void sum();
void main()
{
sum();
getch();
}
void sum()
{
int a,b,c;
printf("enter the values of a and b");
scanf("%d%d",&a,&b);
c=a+b;
printf("sum=%d",c);
}
2 : Functions with no Parameters and Return Values.
1 : In this category, there is no data transfer between the calling
function and called function.
2 : But there is data transfer from called function to the callingfunction.
3 : When no parameters are there , the function cannot receive any
values from the calling function.
4: When the function returns a value, the calling function receives one
value from the called function.
Ex : #include<stdio.h>
#include<conio.h>
int sum();
void main()
{
int c;
clrscr();
c=sum();
printf("sum=%d",c);
getch();
}
int sum()
{
int a,b,c;
printf("enter the values of a and b");
scanf("%d%d",&a,&b);
c=a+b;
return c; }
3 : Functions with Parameters and no Return Values.
1 : In this category, there is data transfer from the calling function to
the called function using parameters.
2 : But there is no data transfer from called function to the calling
function.
3 : When parameters are there , the function can receive any values
from the calling function.
4: When the function does not return a value, the calling function
cannot receive any value from the called function.
Ex : #include<stdio.h>
#include<conio.h>
void sum(int a,int b);
void main()
{
int m,n;
clrscr();
printf("Enter m and n values:");
scanf("%d%d",&m,&n);
sum(m,n);
getch();
}
void sum(int a,int b)
{
int c;
c=a+b;
printf("sum=%d",c);
}
4 : Functions with Parameters and Return Values.
1 : In this category, there is data transfer from the calling function to
the called function using parameters.
2 : But there is no data transfer from called function to the calling
function.
3 : When parameters are there , the function can receive any values
from the calling function.
4: When the function returns a value, the calling function receive a
value from the called function.
Ex : #include<stdio.h>
#include<conio.h>
int sum(int a,int b);
void main()
{
int m,n,c;
clrscr();
printf("Enter m and n values");
scanf("%d%d",&m,&n);
c=sum(m,n);
printf("sum=%d",c);
getch();
}
int sum(int a,int b)
{
int c;
c=a+b;
return c;}
Programs for practice:
C program to find even and odd number using function
#include <stdio.h>

// Function to check even or odd

void checkEvenOdd(int num) {
if (num % 2 == 0) {
printf("%d is an Even number.\n", num);
} else {
printf("%d is an Odd number.\n", num);
}
}

int main() {
int number;
printf("Enter a number: ");
scanf("%d", &number);

// function call
checkEvenOdd(number);

return 0;
C program to find LCM of a number using function
#include <stdio.h> printf("LCM of %d and %d is %d\n", num1, num2, lcm);
return 0;}
// Function to find LCM
int findLCM(int a, int b) {
int max;

// The LCM is always >= the larger number

max = (a > b) ? a : b;

// Loop until max is divisible by both numbers

while(1) {
if(max % a == 0 && max % b == 0) {
return max; // LCM found
}
max++; // try next number
}
}
int main() {
int num1, num2, lcm;

printf("Enter two numbers: ");

scanf("%d %d", &num1, &num2);
lcm = findLCM(num1, num2);
C Program to Calculate the Sum of Natural Numbers :
#include <stdio.h>
int main()
{
int n, i, sum = 0;
printf("Enter a positive integer: ");
scanf("%d", &n);
for (i = 1; i <= n; ++i)
{
sum += i;
}
printf("Sum = %d", sum);
return 0;
}
 Recursion
When function is called within the same function, it is known as recursion in C.
The function which calls the same function, is known as recursive function.
A function that calls itself, and doesn't perform any task after function call, is know
as tail recursion. In tail recursion, we generally call the same function with return
statement.
Features :
• There should be at least one if statement used to terminate recursion.
• It does not contain any looping statements.
Advantages :
• It is easy to use.
• It represents compact programming structures.
Disadvantages :
• It is slower than that of looping statements because each time function is called.
Note: while using recursion, programmers need to be careful to define an exit
condition from the function, otherwise it will go into an infinite loop. Recursive
functions are very useful to solve many mathematical problems, such as calculating
the factorial of a number, generating Fibonacci series, etc.
Example of recursion.
recursionfunction(){
recursionfunction();//calling self function
}
Example of tail recursion in C
// print factorial number using tail recursion
#include<stdio.h>
#include<conio.h>
int factorial (int n)
{
if ( n < 0)
return -1; /*Wrong value*/
if (n == 0)
return 1; /*Terminating condition*/
return (n * factorial (n -1));
}
void main(){
int fact=0;
clrscr();
fact=factorial(5);
printf("\n factorial of 5 is %d",fact);
getch(); } Outputfactorial of 5 is 120
Program: Prime Number Check (No Arguments & No Return Value)
#include <stdio.h>
void checkPrime(); // Function declaration
int main() {
checkPrime(); // Function call
return 0;
}
// Function definition without arguments and without return value
void checkPrime() {
int num, i, flag = 0;
printf("Enter a number: ");
scanf("%d", &num);
if (num <= 1) {
printf("%d is not a prime number.\n", num);
return; }
for (i = 2; i <= num / 2; i++) {
if (num % i == 0) {
flag = 1;
break; } }
if (flag == 0)
printf("%d is a prime number.\n", num);
else
printf("%d is not a prime number.\n", num);
}
Difference between recursion and iteration
Standard Functions
The standard functions are built-in functions. In C programming
language, the standard functions are declared in header files and
defined in .dll files. In simple words, the standard functions can be
defined as "the ready-made functions defined by the system to make
coding easier".
The standard functions are also called as library functions or pre-
defined functions. In C when we use standard functions, we must
include the respective header file using #include statement. For
example, the function printf() is defined in header file stdio.h (Standard
Input Output header file). When we use printf() in our program, we
must include stdio.h header file using #include<stdio.h> statement.
C Programming Language provides the following header files with standard functions.
MATH LIBRARY FUNCTIONS <MATH.H>
CHARACTER LIBRARY FUNCTIONS <CTYPE.H>
TIME LIBRARY FUNCTIONS <TIME.H>
 Storage Classes
In C language, each variable has a storage class which is used to define scope and
life time of a
variable.
Storage: Any variable declared in a program can be stored either in memory or
registers.
Registers are small amount of storage in CPU. The data stored in registers has fast
access
compared to data stored in memory.
Storage class of a variable gives information about the location of the variable in
which it is stored, initial value of the variable, if storage class is not specified;
scope of the variable; life of the variable.
There are four storage classes in C programming.
1 : Automatic Storage class.
2 : Register Storage class.
3 : Static Storage class.
4 : External Storage class.
1: Automatic Storage class :
To define a variable as automatic storage class, the keyword
„auto‟
is used. By defining a variable as automatic storage class, it is
stored in the memory. The default value of the variable will be
garbage value. Scope of the variable is within the block where
it is defined and the life of the variable is until the control
remains within the block.
Syntax : auto data_type variable_name;
auto int a,b;
Example:
void main()
{
int detail;
or
auto int detail; //Both are same
}
The variables a and b are declared as integer type and auto. The keyword auto
is not mandatory. Because the default storage class in C is auto.
Note: A variable declared inside a function without any storage class
specification, is by default an automatic variable. Automatic variables can also
be called local variables because they are local to a function.
Ex : void function1();
void function2(); output:
void main() 10
{ 0
int x=100; 100
function2();
printf(“%d”,x);
}
void function1()
{
int x=10;
printf(“%d”,x);
}
void function2()
{
int x=0;
function1();
printf(“%d”,x);
2: Register Storage class :
To define a variable as register storage class, the keyword „register‟ is
used. If CPU cannot store the variables in CPU registers, then the
variables are assumed as auto and stored in the memory. When a
variable is declared as register, it is stored in the CPU registers. The
default value of the variable will be garbage value. Scope of the
variable within the block where it is defined and the life of the variables
is until the control remains within the block.
Register variable has faster access than normal variable. Frequently
used variables are kept in register. Only few variables can be placed
inside register.
NOTE : We can't get the address of register variable
Sytax : register data_type variable_name;
Ex : void demo(); OUTPUT
void main() 20
{ 20
demo(); 20
demo();
demo();
}
void demo()
{
register int i=20;
printf(“%d\n”,i);
i++;
}
 3 : Static Storage class :
When a variable is declared as static, it is stored in the memory. The
default value of the variable will be zero. Scope of the variable is within
the block where it is defined and the life of the variable persists between
different function calls. To define a variable as static storage class, the
keyword „static‟ is used. A static variable can be initialized only once, it
cannot be reinitialized.
Syntax : static data_type variable_name;
Ex: static int i;
Ex : void demo(); OUTPUT
void main() 20
{ 21
demo(); 22
demo();
demo();
}
void demo()
{
static int i=20;
printf(“%d”,i);
i++;
}
4 : External Storage class :
When a variable is declared as extern, it is stored in the memory. The
default value is initialized to zero. The scope of the variable is global
and the life of the variable is until the program execution comes to an
end. To define a variable as external storage class, the keyword
„extern‟ is used. An extern variable is also called as a global variable.
Global variables remain available throughout the entire program. One
important thing to remember about global variable is that their values
can be changed by any function in the program.
Systax : extern data_type variable_name;
extern int i;
Ex:
int number;
void main()
{
number=10;
}
fun1()
{
number=20;
}
fun2()
{
number=30;
}
Here the global variable number is available to all three
functions.
Ex : void fun1();
void fun2();
int e=20;
void main()
{
fun1();
fun2();
}
void fun1()
{
extern int e;
printf(“e number is :%d”,e);
}
void fun2()
{
printf(“e number is :%d”,e);
}
extern keyword
The extern keyword is used before a variable to inform the compiler
that this variable is declared somewhere else. The extern declaration
does not allocate storage for variables.
Problem when extern is not used
main()
{
a = 10; //Error:cannot find variable a
printf("%d",a);
}
Example Using extern in same file
main()
{
extern int x; //Tells compiler that it is defined somewhere else
x = 10;
printf("%d",x);
}