char str[20];
printf("Enter the string:");
scanf("%s",str);
printf("The string reversed is:%s",strrev(str));
getch();
OUTPUT : Enter the string :subbareddy
The string reversed is : ydderabbus
UNIT – III
FUNCTIONS:
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.
C PROGRAMMING Page 132
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) 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. oints 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: 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.
C PROGRAMMING Page 133
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();
C PROGRAMMING Page 134
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
Eg: int add( int x, int y) int add( int x, int y)
{ {
int z; ( or ) return ( x + y );
z = x + y; }
C PROGRAMMING Page 135
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>
C PROGRAMMING Page 136
#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
C PROGRAMMING Page 137
printf("sum = %d",sum);
return 0;
int addNumbers(int a,int b) // function definition
int result;
result = a+b;
return result; // return statement
Return Statement
C PROGRAMMING Page 138
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.
PARAMETERS :
parameters provides the data communication between the calling function and called function.
They are two types of parametes
C PROGRAMMING Page 139
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 1 : Formal parameters are used in the
function when a function is invoked. function header of a called function.
C PROGRAMMING Page 140
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
allowed.
Ex : c=add(a,b) //variable
Ex : int add(int m,n); //CORRECT
c=add(a+5,b); //expression.
int add(int m+n,int n) //WRONG
c=add(10,20); //constants.
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.
4 : Address of actual parameters can be sent 4 : if formal parameters contains address,
to formal parameters they should be declared as pointers.
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
C PROGRAMMING Page 141
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
C PROGRAMMING Page 142
When a function is called with actual parameters, the values of actual parameters are copied into
formal parameters. If the values of the formal parametes 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.
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);
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;
Output
C PROGRAMMING Page 143
Enter i and j values: 10 20
Before swapping: 10 20
After swapping: 10 20
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);
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;
C PROGRAMMING Page 144
}
Output
Enter i and j values: 10 20
Before swapping:10 20
After swapping: 20 10
Differnce between Call by value and Call by reference
Call by value Call by Reference
1 : When a function is called the values of 1 : When a function is called the address of
variables are passed variables are passed.
2 : Change of formal parameters in the 2 : The actual parameters are changed since
function will not affect the actual the formal parameters indirectly manipulate
parameters in the calling function. the actual parametes.
3 : Execution is slower since all the values 3 : Execution is faster since only address
have to be copied into formal parameters. are copied.
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>
C PROGRAMMING Page 145
#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 calling function.
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();
C PROGRAMMING Page 146
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>
C PROGRAMMING Page 147
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);
C PROGRAMMING Page 148
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;
Inter‐Function Communication
When a function gets executed in the program, the execution control is transferred from calling
function to called function and executes function definition, and finally comes back to the calling
function. In this process, both calling and called functions have to communicate each other to
exchange information. The process of exchanging information between calling and called
functions is called as inter function communication.
In C, the inter function communication is classified as follows...
Downward Communication
Upward Communication
C PROGRAMMING Page 149
