Principles of Programming using C(22POP13) Module -3 (Functions)

MODULE 3
FUNCTIONS

 A function as series of instructions or group of statements with one specific purpose.

 A function is a program segment that carries out some specific, well defined task.
 A function is a self contained block of code that performs a particular task.
Types of functions
 C functions can be classified into two types,
1. Library functions /pre defined functions /standard functions /built in functions
2. User defined functions

1. Library functions /pre defined functions /standard functions/Built in Functions

 These functions are defined in the library of C compiler which are used frequently inthe C program.
 These functions are written by designers of c compiler.
 C supports many built in functions like
 Mathematical functions

 String manipulation functions

 Input and output functions

 Memory management functions

 Error handling functions

 EXAMPLE:
 pow(x,y)-computes xy

 sqrt(x)-computes square root of x

 printf()- used to print the data on the screen

 scanf()-used to read the data from keyboard.

2. User Defined Functions

 The functions written by the programmer /user to do the specific tasks are called userdefined
function(UDF’s).
 The user can construct their own functions to perform some specific task. This type offunctions created by
the user is termed as User defined functions.

Elements of User Defined Function

The Three Elements of User Defined function structure consists of :
1. Function Definition
2. Function Declaration/Function prototype
3. Function call

1. Function Definition:
 A program Module written to achieve a specific task is called as function definition.

Prepared by Sumitha Udaikumar (Dept of ISE) SEACET

Principles of Programming using C(22POP13) Module -3 (Functions)

 Each function definition consists of two parts:

i. Function header

ii. Function body

General syntax of function definition

Function Definition Syntax Function Definition Example

datatypefunctionname(parameters) void add()

{ {
declaration part; executable int sum,a,b;
part; return statement; printf(“enter a and b\n”);
scanf(“%d%d”,&a,&b); sum=a+b;
} printf(“sum is %d”,sum);
}

i. Function header
Syntax
datatype functionname(parameters)
 It consists of three parts
a) Datatype:
 The data type can be int,float,char,double,void.
 This is the data type of the value that the function is expected to return tocalling function.
b) Function name:
 The name of the function.
 It should be a valid identifier.
c) parameters
 The parameters are list of variables enclosed within parenthesis.
 The list of variables should be separated by comma.

Ex: void add( int a, int b)

 In the above example the return type of the function is void
 the name of the function is add and
 The parameters are 'a' and 'b' of type integer.
ii. Function body
 The function body consists of the set of instructions enclosed between { and } .
 The function body consists of following three elements:
a) declaration part: variables used in function body.
b) executable part: set of Statements or instructions to do specific activity.
Prepared by Sumitha Udaikumar (Dept of ISE) SEACET
Principles of Programming using C(22POP13) Module -3 (Functions)

c) return : It is a keyword,it is used to return control back to calling function.

If a function is not returning value then statement is:
return;
If a function is returning value then statement is:
return value;

2. Function Declaration/Function prototype

 The process of declaring the function before they are used is called as functiondeclaration or function
prototype.
 function declaration Consists of the data type of function, name of the functionand parameter list
ending with semicolon.

Function Declaration Syntax

datatypefunctionname(type p1,type p2,………type pn);

Example
int add(int a, int b);
void add(int a, int b);

Note: The function declaration should end with a semicolon ;

3. Function Call:
 The method of calling a function to achieve a specific task is called as functioncall.
 A function call is defined as function name followed by semicolon.
 A function call is nothing but invoking a function at the required place in theprogram to achieve
a specific task.
Ex:
void main()
{
add( ); // function call without parameter
}
Formal Parameters and Actual Parameters

 Formal Parameters:
 The variables defined in the function header of function definition are called
formal parameters.
 All the variables should be separately declared and each declaration must beseparated by commas.
 The formal parameters receive the data from actual parameters.
 Actual Parameters:
 The variables that are used when a function is invoked)in function call) are called
actual parameters.
Prepared by Sumitha Udaikumar (Dept of ISE) SEACET
Principles of Programming using C(22POP13) Module -3 (Functions)

 Using actual parameters, the data can be transferred from calling function.to the called
function.
 The corresponding formal parameters in the function definition receive them.
 The actual parameters and formal parameters must match in number and type ofdata.

 Differences between Actual and Formal Parameters

Actual Parameters Formal Parameters

Actual parameters are also called as Formal parameters are also

argument list. called as dummy parameters.

Ex: add(m,n) Ex:int add(int a, int b)

The variables used in function call arecalled as The variables defined in functionheader
actual parameters are called formal
parameters
Actual parameters are used in calling function Formal parameters are used in the
when a function is called or invoked function header of a calledfunction.
Ex: add(m,n) Example:
Here, m and n are called actual parameters int add(int a, int b)
{ ………..
}

Here, a and b are called formal

parameters.

Actual parameters sends data to theformal Formal parameters receive datafrom the
parameters actual parameters.

Categories of the functions

1. Function with no parameters and no return values

2. Function with no parameters and return values.
3. Function with parameters and no return values
4. Function with parameters and return values

1. Function with no parameters and no return values

1. Function with no parameters and no return values

(void function without parameter)

Calling function Called function

Prepared by Sumitha Udaikumar (Dept of ISE) SEACET

Principles of Programming using C(22POP13) Module -3 (Functions)

/*program to find sum of two numbersusing

function*/
#include<stdio.h> void void add ( )
add( ); {
void main( ) int sum;
{ printf(“enter a and b values\n”);
add( ); scanf(“%d%d”,&a,&b);
} sum=a+b;
printf(“\n The sum is %d”, sum);return;
}

 In this category no data is transferred from calling function to called function,hence called function cannot
receive any values.
 In the above example, no arguments are passed to user defined function add( ).
 Hence no parameters are defined in function header.
 When the control is transferred from calling function to called function a and bvalues are read, they are
added, the result is printed on monitor.
 When return statement is executed ,control is transferred from called function/add
to calling function/main.

Prepared by Sumitha Udaikumar (Dept of ISE) SEACET

Principles of Programming using C(22POP13) Module -3 (Functions)

2. Function with parameters and no return values

(void function with parameter)

Calling function Called function

/*program to find sum of two numbersusing function*/

#include<stdio.h> void
add(int m, int n); void main()
{
void add(int a, int b)
int m,n;
{
printf(“enter values for m and n:”);scanf(“%d
int sum; sum
%d”,&m,&n);
= a+b;
add(m,n);
printf(“sum is:%d”,sum);
} return;
}

 In this category, there is data transfer from the calling function to the called function using parameters.
 But there is no data transfer from called function to the calling function.
 The values of actual parameters m and n are copied into formal parameters a and b.
 The value of a and b are added and result stored in sum is displayed on the screenin called function itself.

Prepared by Sumitha Udaikumar (Dept of ISE) SEACET

Principles of Programming using C(22POP13) Module -3 (Functions)

3. Function with no parameters and with return values

Calling function Called function

/*program to find sum of two numbersusing function*/

#include<stdio.h>int
add(); int add( ) /* function header */
void main()
{
{
int a,b,sum;
int result;
printf(“enter values for a andb:”);
result=add( );
scanf(“%d %d”,&a,&b);
printf(“sum is:%d”,result);
sum= a+b;
}
return sum;
}

 In this category there is no data transfer from the calling function to thecalled function.
 But, there is data transfer from called function to the calling function.
 No arguments are passed to the function add( ). So, no parameters are defined inthe function header
 When the function returns a value, the calling function receives one value from the called function
and assigns to variable result.
 The result value is printed in calling function.

Prepared by Sumitha Udaikumar (Dept of ISE) SEACET

Principles of Programming using C(22POP13) Module -3 (Functions)

4. Function with parameters and with return values

Calling function Called function

/*program to find sum of two numbersusing function*/

#include<stdio.h>int
add();
void main() int add(int a, int b) /* function header */
{
{
int result,m,n;
printf(“enter values for m and n:”); int sum; sum=

scanf(“%d %d”,&m,&n); a+b; return sum;

result=add(m,n); printf(“sum }

is:%d”,result);
}

 In this category, there is data transfer between the calling function and calledfunction.
 When Actual parameters values are passed, the formal parameters in calledfunction can receive the
values from the calling function.
 When the add function returns a value, the calling function receives a value fromthe called function.
 The values of actual parameters m and n are copied into formal parameters a andb.
 Sum is computed and returned back to calling function which is assigned to
variable result.
Passing parameters to functions or Types of argument passing
The different ways of passing parameters to the function are:

 Pass by value or Call by value

 Pass by address or Call by address
1. Call by value:
 In call by value, the values of actual parameters are copied into formal parameters.
 The formal parameters contain only a copy of the actual parameters.
 So, even if the values of the formal parameters changes in the called function, thevalues of the actual
parameters are not changed.
 The concept of call by value can be explained by considering the following program.
Example: #include<stdio.h>

void swap(int a,int b); void

main()
{
Prepared by Sumitha Udaikumar (Dept of ISE) SEACET
Principles of Programming using C(22POP13) Module -3 (Functions)

int m,n;
printf("enter values for a and b:"); scanf("%d
%d",&m,&n);
printf("the values before swapping are m=%d n=%d \n",m,n); swap(m,n);
printf("the values after swapping are m=%d n=%d \n",m,n);
}

void swap(int a, int b)

{
int temp;
temp=a; a=b;
b=temp;
}

 Execution starts from function main( ) and we will read the values for variablesm and n, assume we
are reading 10 and 20 respectively.
 We will print the values before swapping it will print 10 and 20.
 The function swap( ) is called with actual parameters m=10 and n=20.
 In the function header of function swap( ), the formal parameters a and breceive the values 10 and
20.
 In the function swap( ), the values of a and b are exchanged.
 But, the values of actual parameters m and n in function main( ) have not beenexchanged.
 The change is not reflected back to calling function.
2. Call by Address
 In Call by Address, when a function is called, the addresses of actualparameters are sent.
 In the called function, the formal parameters should be declared as pointerswith the same type
as the actual parameters.
 The addresses of actual parameters are copied into formal parameters.
 Using these addresses the values of the actual parameters can be changed.
 This way of changing the actual parameters indirectly using the addresses ofactual parameters is
known as pass by address.

Example: #include<stdio.h>
void swap(int a,int b); void
main()
{
int m,n;
printf("enter values for a and b:"); scanf("%d
%d",&m,&n);

Prepared by Sumitha Udaikumar (Dept of ISE) SEACET

Principles of Programming using C(22POP13) Module -3 (Functions)

printf("the values before swapping are m=%d n=%d \n",m,n); swap(&m,&n);

printf("the values after swapping are m=%d n=%d \n",m,n);
}
void swap(int*a, int*b)
{
int temp; temp=*a;
*a=*b;
*b=temp;
}

Pointer: A pointer is a variable that is used to store the address of another variable.
NOTE: Syntax: datatype *variablename;
Example: int *p;
#include<stdio.h>
void main()
{
int a ,*p;
p=&a;
}
In the above program p is a pointer variable, which is storing the address of variable a.

Differences between Call by Value and Call by reference

Call by Value Call by Address

When a function is called the valuesof When a function is called the addresses ofvariables
variables are passed are passed

The type of formal parameters shouldbe same The type of formal parameters should be same as type
as type of actual parameters of actual parameters, but they have to be declared as
pointers.
Formal parameters contains the Formal parameters contain the addressesof actual
values of actual parameters parameters.

Prepared by Sumitha Udaikumar (Dept of ISE) SEACET

 Module 3

Scope and Life time of a variable

Scope of a variable is defined as the region or boundary of the program in whichthe variable is visible.
There are two types
(i) Global Scope/Program scope
(ii) Local Scope/Block scope
(iii) Function scope
(iv) File scope
i. Global Scope/Program scope:
 The variables that are defined before all functions in global areaare called global variables.
 Memory is allocated only once to these variables and initialized to zero.
 These variables can be accessed by any function and are alive and activethroughout the
program.
 Memory is de-allocated when program execution is over.

 If a variable declared in a function that has same as that of a global variable, then the function will
use the local variable declared within it and ignore the global variable.
 Note: it is good for programmers not to use same name for local and global variables as it may
cause confusion.
 Example :
#include <stdio.h>
int x =10;
void print();
int main()
{
printf (“\n the value of x in the main() = %d”, x);
int x = 2;
printf (“\n the value of local variable x in the main() = %d”, x);
print ();
return 0;
}
void print ()
{
printf (“\n the value of x in print() = %d”, x);
}
Output:
the value of x in the main() = 10
the value of local variable x in the main() = 2
the value of x in print() = 10

11
 Module 3

ii. Local Scope/Block scope:

a. The variables that are defined inside a block { } have local scope and are called as local variable or
automatic variables.

b. They exist only from the point of their declaration until the end of the block.
c. They are not visible outside the block.
Example:
#include <stdio.h>
void print();
int main()
{
int x = 2;
printf (“\n the value of x in the main() = %d”, x);
print ();
return 0;
}
void print ()
{
int x = 1;
printf (“\n the value of x in print() = %d”, x);
}
Output:
the value of x in the main() = 2
the value of x in print() = 1
iii. Function scope
 Function scope indicates that a variable is active and visible from the beginning to the end of the function.
 In C, only the goto label has function scope. This means that the programmer cannot have the same label
names inside a function.
Example:
int main()
{
……
loop : …….. /*a goto label has function scope*/
……
…….
goto loop; /* the goto statement*/
….
return 0;
}
 In the above example, the label loop is visible from the beginning to the end of the main() function.
Therefore, there should not be more than one label having the same name within the main () function.

12
 Module 3

iv. File scope

 A global variable which is accessible until the end of the file, that variable is said to have file scope
 A variable to have file scope, it should be declared with static keyword.
Example : static int x = 10;
 A global static variable can be used anywhere from the file in which it is declares but it is not
accessible by any other file.

 Life Span of a variable

 The life span of a variable is defined as the period during which a variable isactive during
execution of a program.
For Example
 The life span of a global variable is the life span of the program.
 The life span of local variables is the life span of the function, they arecreated.

Storage Classes

Storage class defines the scope and lifetime of variables and functions declared
within a C program
 There are following storage classes which can be used in a C Program:
i. Auto storage class
ii. Register storage class
iii. Static storage class
iv. extern storage class

i. Auto storage class

 The variables defined using auto storage class are called as local variables. Auto stands for automatic storage class. A variable
is in auto storage class by default if it is not explicitly specified.
 The scope of an auto variable is limited with the particular block only. Once the control goes out of the block, the access
is destroyed. This means only the block in which the auto variable is declared can access it.
 A keyword auto is used to define an auto storage class. By default, an uninitialized auto variable contains a garbage value.
 Every time the block in which automatic variable is declared is entered, the variable is initialized with the value is declared.
 Example: auto int age;
 Example program
#include <stdio.h>
void main()
{
int a = 20; //auto integer local to main ()
printf (“\n a= %d”, a);
func1();
}

13
 Module 3

void func1()
{
int a = 30; //auto integer local to func1 ()
printf (“\n a= %d”, a);
}
Output:
a = 20
a = 30

ii. Static storage class

 The variables that are declared using the keyword static are called static variables and have
lifetime over the entire program i.e from time of running the program to termination of the
program.

 The static variables can be declared outside the function (static global variable) and inside the
function (static global variable). They have the characteristics of both local and global variables.

 Static local variables are initialized at the runtime.

 The static variable when defined within a function is not re-initialized when the function is called again and
again. It is initialized just once and the further calls of the function share the value of the static variable.

Ex: static int a,b;

iii. Register storage class
 Any variables declared with the qualifier register is called a register variable.
 This declaration instructs the compiler that the variable under use is to bestored in one of the
registers but not in main memory.
 Register access is much faster compared to memory access.
Example:
register int a;
iv. extern storage class

 Extern stands for external storage class. Extern storage class is used when we have global functions or variables which
are shared between two or more files.

 Keyword extern is used to declaring a global variable or function in another file to provide the reference of variable
or function which have been already defined in the original file.

 The variables defined using an extern keyword are called as global variables. These variables are accessible
throughout the program. Notice that the extern variable cannot be initialized it has already been defined in the original
file.

Examples:

extern int x;

extern void display();

14
 Module 3

Recursion

 Recursion is a method of solving the problem where the solution to a problem depends on solutions
to smaller instances of the same problem.
 Recursive function is a function that calls itself during the execution.

Design of recursive function

 Any recursive function has two elements:

i. Base case

ii. General case or recursive case

i. Base case
 The statement that solves the problem is called base case.
 Every recursive function must have at least one base case.
 It is a special case whose solution can be obtained without using recursion. A base case serves
two purposes:
i). It act as a terminating condition.
ii). the recursive function obtains the solution from the base case itreaches.
ii. General case:
 The statement that reduces the size of the problem is called general case.
 This is done by calling the same function with reduced size.
 In general recursive function of factorial problem can be written as

15
 Module 3

n! = 1 , if n = 0 //base case

n*(n-1)! , otherwise //general case

5!=5*4!

4!=4*3!

3!=3*2!
2!=2*1!

1!=1*0!

0!==1 This is a base case

1!=1*0!=1*1=1

2!=2*1!=2*1=2

3!=3*2!, 3!=3*2=6

4!=4*3! , 4!=4*6=24

5!=5*4!, 5*=24,

120(answer)

16
 Module 3
Example 1.
/******* Factorial of a given number using Recursion ******/

#include<stdio.h>
int fact(int n);
void main( )
{
int num,result;

printf("enter number:");
scanf("%d",&num); result=fact(num);
printf("The factorial of a number is: %d",result);
}
int fact(int n)
{
if(n==0)
return 1;
else

return (n*fact(n-1));
}
out put: enter number : 5

The factorial of a number is: 120

Example 2: /******* fibonacci series using Recursion ******/

#include<stdio.h>
int fibonacci(int);
int main(){
int n, i;
printf("Enter the number of element you want in series :n");
scanf("%d",&n);
printf("fibonacci series is : n");
for(i=0;i<n;i++) {
printf("%d ",fibonacci(i));
}
}
int fibonacci(int i){
if(i==0)
return 0;
else if(i==1)
return 1;
else
return (fibonacci(i-1)+fibonacci(i-2));
}
Output: Enter the number of terms 5
Fibonacci series
0 1 1 2 3

17