CS8251 Programming in C UNIT III

UNIT III FUNCTIONS AND POINTERS

Introduction to functions: Function prototype, function definition, function call,
Built-in functions (string functions, math functions) – Recursion – Example
Program: Computation of Sine series, Scientific calculator using built-in functions,
Binary Search using recursive functions – Pointers – Pointer operators – Pointer
arithmetic – Arrays and pointers – Array of pointers – Example Program: Sorting
of names – Parameter passing: Pass by value, Pass by reference – Example
Program: Swapping of two numbers and changing the value of a variable using
pass by reference

3.1 Introduction to functions

A function is a subprogram of one or more statements that performs a specific task
when called.
Advantages of Functions:
1. Code reusability
2. Better readability
3. Reduction in code redundancy
4. Easy to debug & test.
Classification of functions:
• Based on who develops the function
• Based on the number of arguments a function accepts
1. Based on who develops the function
There are two types.
1. Library functions
2. User-defined functions
1. Library functions [Built-in functions]

1 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

Library functions are predefined functions. These functions are already developed
by someone and are available to the user for use. Ex. printf( ), scanf( ).
2. User-defined functions
User-defined functions are defined by the user at the time of writing a program.
Ex. sum( ), square( )

Using Functions
A function can be compared to a black box that takes in inputs, processes it, and
then outputs the
result. Terminologies using functions are:
▪ A function f that uses another function g is known as the calling function,
and g is known as the called function.
▪ The inputs that a function takes are known as arguments.
▪ When a called function returns some result back to the calling function, it is
said to return that result.
▪ The calling function may or may not pass parameters to the called function.
If the called function accepts arguments, the calling function will pass
parameters, else not.
▪ Function declaration is a declaration statement that identifies a function’s
name, a list of arguments that it accepts, and the type of data it returns.
▪ Function definition consists of a function header that identifies the function,
followed by the body of the function containing the executable code for that
function.

3.2 Function Prototype

Before using a function, the compiler must know the number of parameters
and the type of parameters that the function expects to receive and the data type of
2 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

value that it will return to the calling program. Placing the function declaration
statement prior to its use enables the compiler to make a check on the arguments
used while calling that function.
Syntax:
return_data_type function_name(data_type variable1, data_type variable2,..);
Here, function_name is a valid name for the function. Naming a function
follows the same rules that are followed while naming variables. A function should
have a meaningful name that must specify the task that the function will perform.
return_data_type specifies the data type of the value that will be returned
to the calling function as a result of the processing performed by the called
function.
(data_type variable1, data_type variable2, ...) is a list of variables of
specified data types.
These variables are passed from the calling function to the called function.
They are also known as arguments or parameters that the called function accepts to
perform its task.

3.3 Function definition

When a function is defined, space is allocated for that function in the memory. A
function definition comprises of two parts:
▪ Function header
▪ Function body
The syntax of a function definition can be given as:
return_data_type function_name(data_type variable1, data_type variable2,..)
{
.............
statements
3 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

.............
return(variable);
}
While return_data_type function_name(data_type variable1, data_type
variable2,...) is known as the function header, the rest of the portion comprising of
program statements within the curly brackets { } is the function body which
contains the code to perform the specific task.
Note that the function header is same as the function declaration. The only
difference between the two is that a function header is not followed by a semi-
colon.

3.4 Function Call

The function call statement invokes the function. When a function is invoked, the
compiler jumps to the called function to execute the statements that are a part of
that function. Once the called function is executed, the program control passes
back to the calling function.
Syntax:
function_name(variable1, variable2, ...);
The following points are to be noted while calling a function:
▪ Function name and the number and the type of arguments in the function call
must be same as that given in the function declaration and the function
header of the function definition.
▪ Names (and not the types) of variables in function declaration, function call,
and header of function definition may vary.
▪ Arguments may be passed in the form of expressions to the called function.
In such a case, arguments are first evaluated and converted to the type of
formal parameter and then the body of the function gets executed.
4 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

▪ If the return type of the function is not void, then the value returned by the
called function may be assigned to some variable as given below.
variable_name = function_name(variable1, variable2, ...);

Working of a function
void main()
{
int x,y,z;
int abc(int, int, int) // Function declaration
…..
…..
abc(x,y,z) // Function Call
… Actual arguments
…
}

int abc(int i, int j, int k) // Function definition

{ Formal arguments
…….
….
return (value);
}

Calling function – The function that calls a function is known as a calling

function.
Called function – The function that has been called is known as a called function.

5 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

Actual arguments – The arguments of the calling function are called as actual
arguments.
Formal arguments – The arguments of called function are called as formal
arguments.

Steps for function Execution:

1. After the execution of the function call statement, the program control is
transferred to the called function.
2. The execution of the calling function is suspended and the called function
starts execution.
3. After the execution of the called function, the program control returns to
the calling function and the calling function resumes its execution.

3.5 Built-in functions (string functions, math functions)

The standard library functions are built-in functions in C programming to
handle tasks such as mathematical computations, I/O processing, string handling
etc. These functions are defined in the header file.
The printf() is a standard library function to send formatted output to the
screen (display output on the screen). This function is defined in "stdio.h" header
file.
There are other numerous library functions defined under "stdio.h", such
as scanf(), fprintf(), getchar() etc. Once you include "stdio.h" in your program, all
these functions are available for use.

Library of Mathematical functions.

These are defined in math.h header file.
Example:

6 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

1 double cos(double x)- Returns the cosine of a radian angle x

2 double sin(double x)- Returns the sine of a radian angle x.
3 double exp(double x)- Returns the value of e raised to the xth power
double log(double x)
4
Returns the natural logarithm (base-e logarithm) of x.
double sqrt(double x)
5
Returns the square root of x.
double pow(double x, double y)
6
Returns x raised to the power of y.

Library of standard input & output functions

Header file: stdio.h
Example:
1 printf() This function is used to print the character, string, float, integer,
octal and hexadecimal values onto the output screen
2 scanf() This function is used to read a character, string, and numeric data
from keyboard.
3 getc() It reads character from file
4 gets() It reads line from keyboard

Library of String functions:

Header file: string.h
Example:
Functions Descriptions
strlen() Determines the length of a String
strcpy() Copies a String from source to destination
strcmp() Compares two strings

7 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

strlwr() Converts uppercase characters to lowercase

strupr() Converts lowercase characters to uppercase

Example: strlen function

#include <stdio.h>
int main() {
char string1[20];
char string2[20];
strcpy(string1, "Hello");
strcpy(string2, "Hellooo");
printf("Length of string1 : %d\n", strlen( string1 ));
printf("Length of string2 : %d\n", strlen( string2 ));
return 0;
}
Output:
Length of string1 : 5
Length of string2 : 7

Example: strcpy function

#include <stdio.h>
int main() {
char input_str[20];
char *output_str;
strcpy(input_str, "Hello");
printf("input_str: %s\n", input_str);
output_str = strcpy(input_str, "World");

8 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

printf("input_str: %s\n", input_str);

printf("output_str: %s\n", output_str);
return 0;
}

Output:
input_str: Hello
input_str: World
output_str: World

Example :strcmp function

#include<stdio.h>
#include<string.h>
void main( )
{
char one[20] = “William Lambton”;
char two[20] = “William Lamberton”;
if(strcmp(one, two) == 0)
printf(“The names are the same.”);
else
printf(“The names are different.”);
}

Output:
The names are different

Example: Strupr() and strlwr()

9 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

#include<stdio.h>
#include<string.h>
int main( )
{
char str[] = “ String Functions”;
printf(“%s \n”, strupr(str));
printf(“%s \n”, strlwr(str));
return 0;
}
Output:
STRING FUNCTIONS
string functions

3.6 Recursion
A function that calls itself is known as a recursive function.
Direct & Indirect Recursion:
Direct Recursion:
A function is directly recursive if it calls itself.
A( )
{
….
….
A( );// call to itself
….
}
Indirect Recursion:
Function calls another function, which in turn calls the original function.
10 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

A( )
{
…
…
B( );
…
}
B( )
{
…
…
A( );// function B calls A
…
}
Consider the calculation of 6! ( 6 factorial )
ie 6! = 6 * 5 * 4 * 3 * 2 * 1
6! = 6 * 5!
6! = 6 * ( 6 - 1 )!
n! = n * ( n - 1 )!

Types of Recursion
Direct Recursion
A function is said to be directly recursive if it explicitly calls itself. Here, the
function Func() calls itself for all positive values of n, so it is said to be a directly
recursive function.
int Func (int n)
{
11 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

if (n == 0)
return n;
else
return (Func (n–1));
}

Indirect Recursion
A function is said to be indirectly recursive if it contains a call to another function
which ultimately calls it. These two functions are indirectly recursive as they both
call each other.
int Funcl (int n)
{
if (n == 0)
return n;
else
return Func2(n);
}
int Func2(int x)
{
return Func1(x–1);
}

Tail Recursion
A recursive function is said to be tail recursive if no operations are pending to be
performed when the recursive function returns to its caller. When the called
function returns, the returned value is immediately returned from the calling
function.
12 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

int Fact(int n)
{
if (n == 1)
return 1;
else
return (n * Fact(n–1));
}
The above function is a nontail-recursive function, because there is a
pending operation of multiplication to be performed on return from each recursive
call. Whenever there is a pending operation to be performed, the function becomes
non-tail recursive. In such a non-tail recursive function, information about each
pending operation must be stored, so the amount of information directly depends
on the number of calls.
int Fact(n)
{
return Fact1(n, 1);
}
int Fact1(int n, int res)
{
if (n == 1)
return res;
else
return Fact1(n–1, n*res);
}
The same factorial function can be written in a tail recursive manner. In the code,
Fact1 function preserves the syntax of Fact(n). Here the recursion occurs in the
Fact1 function and not in Fact function. Fact1 has no pending operation to be
13 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

performed on return from recursive calls. The value computed by the recursive call
is simply returned without any modification. So in this case, the amount of
information to be stored on the system stack is constant (only the values of n and
res need to be stored) and is independent of the number of recursive calls.

E.g. Program:
#include<stdio.h>
#include<conio.h>
void main()
{
int fact(int);
int n,f;
printf(“Enter the number \n”);
scanf(“%d”,&n);
f=fact(n);
printf(“The factorial of a number =%d”,f);
getch();
}
int fact(int n)
{
if(n==1)
return(1);
else
return n*fact(n-1);
}
OUTPUT
Enter the number to find the factorial
14 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

5
The factorial of a number=120

Pattern of Recursive Calls:

Based on the number of recursive calls, the recursion is classified in to 3
types. They are,
1. Linear Recursion - Makes only one recursive call.
2. Binary Recursion - Calls itself twice.
3. N-ary recursion - Calls itself n times.

Converting Recursive Functions to Tail Recursive

A non-tail recursive function can be converted into a tail-recursive function
by using an auxiliary parameter as we did in case of the Factorial function. The
auxiliary parameter is used to form the result. When we use such a parameter, the
pending operation is incorporated into the auxiliary parameter so that the recursive
call no longer has a pending operation.
Recursive functions can also be characterized depending on the way in
which the recursion grows in a linear fashion or forming a tree structure as shown
below:
int Fibonacci(int num)
{
if(num == )
return ;
else
return (Fibonacci(num - 1) + Fibonacci(num – 2));
}
else if (num == 1)
15 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

return 1;
Observe the series of function calls. When the function pending operations in turn
calls the function
Fibonacci(7) = Fibonacci(6) + Fibonacci(5)
Fibonacci(6) = Fibonacci(5) + Fibonacci(4)
Fibonacci(5) = Fibonacci(4) + Fibonacci(3)
Fibonacci(4) = Fibonacci(3) + Fibonacci(2)
Fibonacci(3) = Fibonacci(2) + Fibonacci(1)
Fibonacci(2) = Fibonacci(1) + Fibonacci(0)
Now we have, Fibonacci(2) = 1 + 0 = 1
Fibonacci(4) = 2 + 1 = 3
Fibonacci(5) = 3 + 2 = 5
Fibonacci(6) = 3 + 5 = 8
Fibonacci(7) = 5 + 8 = 13

On the contrary, a recursive function is said to be tree recursive (or non-

linearly recursive) if the pending operation makes another recursive call to the
function. For example, the Fibonacci function in which the pending operations
recursively call the Fibonacci function.

Tower of Hanoi
The tower of Hanoi is one of the main applications of recursion. It says, ‘if
you can solve n–1 cases, then you can easily solve the nth case’. The figure (a)
below shows three rings mounted on pole A. The problem is to move all these
rings from pole A to pole C while maintaining the same order. The main issue is
that the smaller disk must always come above the larger disk.

16 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

In our case, A is the source pole, C is the destination pole, and B is the spare
pole. To transfer all the three rings from A to C, we will first shift the upper two
rings (n–1 rings) from the source pole to the spare pole. We move the first two
rings from pole A to B as shown in figure (b) .
Now that n–1 rings have been removed from pole A, the nth ring can be
easily moved from the source pole (A) to the destination pole (C). Figure (c) shows
this step.
The final step is to move the n–1 rings from the spare pole (B) to the
destination pole (C). This is shown in Fig. (d)
To summarize, the solution to our problem of moving n rings from A to C using B
as spare can be given as:
Base case: if n=1
▪ Move the ring from A to C using B as spare
Recursive case:
▪ Move n – 1 rings from A to B using C as spare
▪ Move the one ring left on A to C using B as spare
▪ Move n – 1 rings from B to C using A as spare

Figure (a)

17 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

Figure (b)

Figure (c)

Figure (d)

3.7 Example Program

Program for Computation of Sine series
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()

18 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

{
int i, n ;
float x, val, sum, t ;
clrscr() ;
printf("Enter the value for x : ") ;
scanf("%f", &x) ;
printf("\nEnter the value for n : ") ;
scanf("%d", &n) ;
val = x ;
x = x * 3.14159 / 180 ;
t=x;
sum = x ;
for(i = 1 ; i < n + 1 ; i++)
{
t = (t * pow((double) (-1), (double) (2 * i - 1)) * x * x) / (2 * i * (2 * i + 1)) ;
sum = sum + t ;
}
printf("\nSine value of %f is : %8.4f", val, sum) ;
getch() ;
}
Output:
Enter the value for x : 30
Enter the value for n : 20
Sine value of 30.000000 is : 0.5000

Scientific calculator using built-in functions

19 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

Program for binary search using recursive function

#include<stdio.h>
int main()
{

int a[10],i,n,m,c,l,u;

printf("Enter the size of an array: ");

scanf("%d",&n);

printf("Enter the elements of the array: " );

for(i=0;i<n;i++)
{
scanf("%d",&a[i]);
}

printf("Enter the number to be search: ");

scanf("%d",&m);

l=0,u=n-1;
c=binary(a,n,m,l,u);
if(c==0)
20 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

printf("Number is not found.");

else
printf("Number is found.");

return 0;
}

int binary(int a[],int n,int m,int l,int u)

{

int mid,c=0;

if(l<=u)
{
mid=(l+u)/2;
if(m==a[mid])
{
c=1;
}
else if(m<a[mid])
{
return binary(a,n,m,l,mid-1);
}
else
return binary(a,n,m,mid+1,u);
}
else
21 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

return c;
}

Output:
Enter the size of an array: 5
Enter the elements of the array: 8 9 10 11 12
Enter the number to be search: 8
Number is found.

3.8 Pointers
Definition:
A pointer is a variable that stores the address of a variable or a function
Advantages
1. Pointers save memory space
2. Faster execution
3. Memory is accessed efficiently.
Declaration
datatype *pointername;

E.g ) int *p //p is an pointer to an int

float *fp //fp is a pointer to a float

int a=10; p a
int *p=&a;
2000 10

4000 2000
p is an integer pointer & holds the address of an int variable a.

Pointer to pointer
A pointer that holds the address of another pointer variable is known as a
pointer to pointer.
E.g.
22 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

int **p;

p is a pointer to a pointer to an integer.

int a=12;
int *p=&a; a
int **pptr=&p;
12
p 4000 4000

6000

6000 pptr
8000
So **pptr=12

3.9 Operations on pointers

1. Referencing operation: A pointer variable is made to refer to an object.

Reference operator(&) is used for this. Reference operator is also known as
address of (&) operator.

Eg) float a=12.5;

float *p;
p=&a;

a 12.5

1000 1000
P
2000

2. Dereferencing a pointer
The object referenced by a pointer can be indirectly accessed by
dereferencing the pointer. Dereferencing operator (*) is used for this .This
operator is also known as indirection operator or value- at-operator

Eg) int b;
int a=12;
a 12 int *p;
23 B. Shanmuga Sundari csenotescorner.blogspot.com
1000
 CS8251 Programming in C UNIT III

1000 p=&a;
b=*p; \\value pointed by p(or)value
at 1000=12,
p so b=12
2000
Example program
#include<stdio.h>
void main() Note
{
int a=12; %p is used for addresses; %u
int *p; can also be used.
int **pptr;
p=&a; *p=value at p
=value at (1000)=12
pptr=&p;
printf(“a value=%d”,a); *pptr=value at(pptr)
printf(“value by dereferencing p is %d \n”,*p); =value at(value at (2000))
printf(“value by dereferencing pptr is %d \n”,**pptr); =value at (1000)=12
printf(“value of p is %u \n”,p);
printf(“value of pptr is %u\n”,pptr);
}
Output:
a value=12
value by dereferencing p is 12
value by dereferencing pptr is 12
value of p is 1000
value of pptr is 2000

a 12

1000 p 1000

2000 pptr 2000

3000

3.10 Pointer arithmetic

Arithmetic operations on pointer variables are also possible.

24 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

E.g.) Addition, Increment, Subtraction, Decrement.

1. Addition
(i) An addition of int type can be added to an expression of pointer type. The result
is pointer type.(or)A pointer and an int can be added.

Eg) if p is a pointer to an object then

p+1 =>points to next object
p+i=>point s to ith object after p

(ii)Addition of 2 pointers is not allowed.

2. Increment
Increment operator can be applied to an operand of pointer type.
3. Decrement
Decrement operator can be applied to an operand of pointer type.
4. Subtraction
i) A pointer and an int can be subtracted.
ii) 2 pointers can also be subtracted.

25 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

S.no Operator Type of Type of Result Example Initial Final Description

operand operand type value value
1 2
1 + Pointer int Pointer Result =
to type to type initial value
T T of ptr +int
operand *
sizeof (T)

Eg. int * int int * p=p+5 p=2000 2010 2000+5*2=

2010
2 ++ Pointer Pointer Post
to type - to type increment
T T Result =
initial value
of pointer

Pre-
increment
Result =
initial value
of pointer +
sizeof (T)
Eg. post float* - float* ftr=p++ ftr=? ftr=2000

26 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

increment p=2000 p=2004 Value of ptr

= Value of
ptr
+sizeof(T)
3 - Pointer int Pointer Result =
to type to type initial value
T T of ptr - int
operand *
sizeof (T)
E.g. float* int float* p=p-1 p=2000 1996 2000 – 1 *
4 = 2000-
4=1996
4 -- Pointer Pointer Post
to type - to type decrement
T T Result =
initial value
of pointer

Pre-
decrement
Result =
initial value
of pointer –
sizeof(T)
Eg.pre float* - float* ftr=--p ftr=? ftr=1996
decrement p=2000 p=1996 Value of ptr

27 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

= Value of
ptr –
sizeof(T)

3.11. Pointers and Arrays

In C language, pointers and arrays are so closely related.
i) An array name itself is an address or pointer. It points to the address of first
element (0th element) of an array.
Example
#include<stdio.h>
void main()
{
int a[3]={10,15,20};
printf(“First element of array is at %u\n”, a);
10 15 20
printf(“2nd element of array is at %u\n”, a+1);
printf(“3nd element of array is at %u\n”, a+2);
1000 1002 1004
}
Output
First element of array is at 1000
2nd element of array is at 1002
3nd element of array is at 1004

ii)Any operation that involves array subscripting is done by using pointers in c

language.
28 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

E.g.) E1[E2]=>*(E1+E2)
Example
#include<stdio.h>
void main()
{
int a[3]={10,15,20};
printf(“Elements are %d %d %d\n”, a[0],a[1],a[2]);
printf(“Elements are %d %d %d\n”, *(a+0),*(a+1),*(a+2);
}
Output:
Elements are 10 15 20
Elements are 10 15 20

3.12 Array of pointers

An array of pointers is a collection of addresses. Pointers in an array must be
the same type.
int a=10,b=20,c=30;
int *b[3]={&a,&b,&c};
a b c

10 20 30

4000 4100 4400

4000 4100 4400

29 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

5000 5002 5004

Example:
Now look at another code in which we store the address of three individual arrays
in the array of pointers:
int main()
{
int arr1[]={1,2,3,4,5};
int arr2[]={0,2,4,6,8};
int arr3[]={1,3,5,7,9};
int *parr[3] = {arr1, arr2, arr3};
int i;
for(i = 0;i<3;i++)
printf(«%d», *parr[i]);
return 0;
}
Output
101

3.13 Example Program

Sorting of names
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{

30 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

char *x[20];
int i,n=0;
void reorder(int n,char *x[]);
clrscr();
printf("Enter no. of String : ");
scanf("%d",&n);
printf("\n");

for(i=0;i<n;i++)
{
printf("Enter the Strings %d : ",i+1);
x[i]=(char *)malloc(20*sizeof(char));
scanf("%s",x[i]);
}
reorder(n,x);
printf("\nreorder list is : \n");
for(i=0;i<n;i++)
{
printf("%d %s\n",i+1,x[i]);
}
getch();
}
void reorder(int n,char *x[])
{
int i,j;
char t[20];
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(strcmp(x[i],x[j])>0)
{
strcpy(t,x[j]);
strcpy(x[j],x[i]);
strcpy(x[i],t);
}
return;
}

Output:
Enter no. of string 5
31 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

Enter the Strings 1 kailash

Enter the Strings 2 Aswin
Enter the Strings 3 Zulphia
Enter the Strings 4 Babu
Enter the Strings 5 Clinton
Reorder list is
Aswin
Babu
Clinton
kailash
Clinton

3.14 Parameter passing

Whenever we call a function then sequence of executable statements gets executed.
We can pass some of the information to the function for processing
called argument. There are two ways in which arguments can be passed from
calling function to called function. They are:
1. Pass by value
2. Pass by reference

1. Pass by value (Call by value)

➢ In this method the values of actual arguments are copied to formal
arguments.
➢ Any change made in the formal arguments does not affect the actual
arguments.
➢ Once control, return backs to the calling function the formal
parameters are destroyed.
32 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

E.g. Program:

#include<stdio.h>
#include<conio.h>
void main()
{
int a,b;
void swap(int ,int);
a=10;
b=20;
printf("\n Before swapping: a = %d and b = %d",a,b);
swap(a, b);
printf("\n After swapping: a= %d and b= %d",a,b);
getch();
}

void swap(int a1,int b1)

{
int temp;
temp=a1;
a1=b1;
b1=temp;
}

OUTPUT:
Before swapping: a =10 and b =20
33 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

After swapping: a =10 and b = 20

34 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

Main function
a b

10 20

1000 1002
Swap function
a1 b1
10 20

2000 2002
After swap function
a1 b1
20 10

2000 2002

2. Pass by reference ( Call b y reference)

➢ In this method, the addresses of the actual arguments are passed to formal
argument.
➢ Thus formal arguments points to the actual arguments.
➢ So changes made in the arguments are permanent.

Example Program:

35 B. Shanmuga Sundari csenotescorner.blogspot.com

 CS8251 Programming in C UNIT III

#include<stdio.h>
#include<conio.h>
void main()
{
int a,b;
void swap(int *,int *);
a=10;
b=20;
printf("\n Before swapping: a= %d and b= %d",a,b);
swap(&a,&b);
printf("\n After swapping: a= %d and b= %d",a,b);
getch();
}
void swap(int *a1,int *b1)
{
int t;
t = *a1;
*a1 = *b1;
*b1 = t;
}

OUTPUT:
Before swapping: a = 10 and b = 20
After swapping: a = 20 and b = 10
Main function
a b
36 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

10 20

1000 1002
Swap function
a1 b1
1000 1002

a1, b1 points to a and b.

2000 2002
After swap function
a b
20 10

1000 1002

3.15 Example Program: Swapping of two numbers and changing the value of
a variable using pass by reference
#include<stdio.h>
#include<conio.h>
void swap(int *num1, int *num2);
void main() {
int x, y;
printf("\nEnter First number : ");
scanf("%d", &x);
printf("\nEnter Second number : ");
scanf("%d", &y);
37 B. Shanmuga Sundari csenotescorner.blogspot.com
 CS8251 Programming in C UNIT III

printf("\nBefore Swaping x = %d and y = %d", x, y);

swap(&x, &y); // Function Call - Pass By Reference
printf("\nAfter Swaping x = %d and y = %d", x, y);
getch();
}
void swap(int *num1, int *num2) {
int temp;
temp = *num1;
*num1 = *num2;
*num2 = temp;
}

Output:
Enter First number : 12
Enter Second number : 21

Before Swaping x = 12 and y = 21

After Swaping x = 21 and y = 12

38 B. Shanmuga Sundari csenotescorner.blogspot.com