UNIT 4 : functions

1.functions, types of functions, types of user defined functions

2.function declaration and definition
3.function parameters (or) arguments, return type of function
4.standard library functions in c
5.parameter passing techniques(call by value and call by
reference)
6.passing pointers and arrays to functions
7.recursion, finding number factorial, Fibonacci series using
functions, limitations of recursion
8.dynamic memory allocation( malloc(),calloc(),realloc(),free()
functions)
 UNIT 4
Functions
A function is a block of code which only runs when it is called.

You can pass data, known as parameters, into a function.

Functions are used to perform certain actions, and they are important for
reusing code: Define the code once, and use it many times.

types of function
There are two types of function in C programming:
 Standard library functions
 User-defined functions

Standard library functions
The standard library functions are built-in functions in C programming.
These functions are defined in header files. For example,
 The printf(),scanf(),main() are standard library function. This function is
defined in the stdio.h header file.
Hence, to use the printf(),scanf()functions, we need to include
the stdio.h header file using #include <stdio.h>.

EXAMPLE:
#include <stdio.h>
void main()
{
printf("Hello World!");

User-defined function
You can also create functions as per your need. Such functions created by
the user are known as user-defined functions.
 How user-defined function works( structure of function):

#include <stdio.h>
void myfun()
{
... .. ...
... .. ...
}
int main()
{
myfun();

The execution of a C program begins from the main() function.

When the compiler encounters myfun();, control of the program jumps to
And, the compiler starts executing the codes inside myfun().
The control of the program jumps back to the main() function once
code inside the function definition is executed.

Advantages of user-defined function

1. The program will be easier to understand, maintain and easy to remove
errors.
2. Reusable codes that can be used in other programs
3. A large program can be divided into smaller modules. Hence, a large
project can be divided among many programmers.

Types of user defined functions in C

Different types of user-defined functions: A function, depending on whether
arguments are present or not and whether a value is returned or not, may
belong to one of the following categories.
  Category I: Functions with no arguments and no return values
 Category 2: Functions with no arguments and with return values
 Category 3: Functions with arguments and no return values
 Category 4: Functions with arguments and with return values

1) Functions with no arguments and no return value:

The following syntax describes how to write a function which neither takes
any arguments nor returns any value.

Syntax for function definition:

void functionName() //Return type in the function header should be 'void'

and do not give any arguments within the parenthesis.
{
........
........
}//Need not return any value

Example program :
#include<stdio.h>

void myFunction()

printf("I AM NAGENDRA");

int main()

myFunction();

myFunction();

myFunction();
return 0;

Output:

I AM NAGENDRA

I AM NAGENDRA

I AM NAGENDRA

2) Functions with no arguments and with return values:

The following syntax shows how to write a function which does not take any
arguments but returns some value back to the calling function.

Syntax for function definition :

returnType functionName() //Identify what type of value will be returned

by the function and accordingly specify the return type and empty

{
parenthesis since there is no argument
....
....
return value;
}

Example program :
#include<stdio.h>

int myFunction()

printf("I AM NAGENDRA");

return 0;

}
int main()

myFunction();

myFunction();

myFunction();

return 0;

Output:

I AM NAGENDRA

I AM NAGENDRA

I AM NAGENDRA

3) Functions with arguments and no return values:

Syntax for function definition:

void functionName(typel argl, type2 arg2,...... typeN argN)

{
....
....
return;
}

Example program:
#include<stdio.h>

void myFun(char a[], int b)

printf("%s,%d\n”,a,b);

}
int main()

myFun ("madhu", 3);

myFun ("naveen", 14);

myFun ("yashwant", 30);

return 0;

Output:

madhu,3

Naveen,14

Yashwant,30

4) Functions with arguments and with return values:

Syntax for function definition:

returnType functionName(typel argi, type2 arg2,.........typeN argN)

{
....
....
return value;
}

Example program:
#include<stdio.h>

int myFun(char a[], int b)

{

printf("%s,%d\n”,a,b);

return 0;

int main()

myFun ("madhu", 3);

myFun ("naveen", 14);

myFun ("yashwant", 30);

return 0;

Output:

madhu,3

Naveen,14

Yashwant,30

One function can call any number of functions:

Program:

#include <stdio.h>

void india()
{

printf("i am in india\n");

void hyderabad()

printf("i am in hyderabad\n");

void main()

printf("i am in main function\n");

india();

hyderabad();

Output:

i am in main function

i am in india

i am in hyderabad
 C Function Declaration and Definition
A function consist of two parts:

 Declaration: the function's name, return type, and parameters (if

any)
 Definition: the body of the function (code to be executed)

Example program:

#include <stdio.h>

void myFunction();// Function declaration

int main()// The main method

myFunction(); // call the function

return 0;

void myFunction()// Function definition

printf("hello!");

Output:

hello!

C Function Parameters (or) arguments

Parameters (or) Arguments:
Information can be passed to functions as a parameter. Parameters act as
variables inside the function.

Parameters are specified after the function name, inside the parentheses.
You can add as many parameters as you want, just separate them with a
comma:

Syntax:
returnType functionName(parameter1, parameter2, parameter3)

{
//code_to_be_executed
}

Example:

#include <stdio.h>

void myFun(char a[], int b)

printf("%s,%d\n”,a,b);

int main()

myFun ("madhu", 3);

myFun ("naveen", 14);

myFun ("yashwant", 30);

return 0;

Output:

madhu,3
Naveen,14

Yashwant,30

Return Values (or) Return type:

The void keyword, used in the previous examples, indicates that the
function should not return a value. If you want the function to return a value,
you can use a data type (such as int or float, etc.) instead of void, and use
the return keyword inside the function:

Example:

#include <stdio.h>

int myfun(int x, int y)

return x + y;

int main()

printf("Result is: %d", myfun(5, 3));

return 0;

Output:

Result is:8
STANDARD LIBRARY FUNCTIONS IN C
Library functions are built-in functions that are grouped
together and placed in a common location called library.
Each function here performs a specific operation. We can use
this library functions to get the pre-defined output.
All C standard library functions are declared by using many
header files. These library functions are created at the time of
designing the compilers.
We include the header files in our C program
by using #include<filename.h>. Whenever the program is
run and executed, the related files are included in the C
program.
Header File Functions
Some of the header file functions are as follows −
 stdio.h − It is a standard i/o header file in which Input/output functions
are declared
 conio.h − This is a console input/output header file.
 string.h − All string related functions are in this header file.
 stdlib.h − This file contains common functions which are used in the
C programs.
 math.h − All functions related to mathematics are in this header file.
 time.h − This file contains time and clock related functions.Built
functions in stdio.h
Built functions in stdio.h
Let’s see what are the built functions present in stdio.h library function.

Sl.No Function & Description

1 printf()This function is used to print the all char, int, float, string etc.,
values onto the output screen.

2 scanf()This function is used to read data from keyboard.

3 getc()It reads character from file.

4 gets()It reads line from keyboard.

5 getchar()It reads character from keyboard.

6 puts()It writes line to o/p screen.

7 putchar()It writes a character to screen.

8 fopen()All file handling functions are defined in stdio.h header file.

Sl.No Function & Description

9 fclose()Closes an opened file.

10 getw()Reads an integer from file.

11 putw()Writes an integer to file.

12 fgetc()Reads a character from file.

13 putc()Writes a character to file.

14 fputc()Writes a character to file.

15 fgets()Reads string from a file, one line at a time.

16 f puts()Writes string to a file.

17 feof()Finds end of file.

18 fgetcharReads a character from keyboard.

19 fgetc()Reads a character from file.

20 fprintf()Writes formatted data to a file.

21 fscanf()Reads formatted data from a file.

22 fputcharWrites a character from keyboard.

Sl.No Function & Description

23 fseek()Moves file pointer to given location.

24 SEEK_SETMoves file pointer at the beginning of the file.

25 SEEK_CURMoves file pointer at given location.

26 SEEK_ENDMoves file pointer at the end of file.

27 ftell()Gives current position of file pointer.

28 rewind()Moves file pointer to the beginning of the file.

29 putc()Writes a character to file.

30 sprint()Writes formatted output to string.

31 sscanf()Reads formatted input from a string.

32 remove()Deletes a file.

33 flush()Flushes a file.
 Parameter Passing Techniques in C
Or
Inter function communication

There are different ways in which parameter data can be passed into and
out of methods and functions. Let us assume that a function B() is called
from another function A(). In this case A is called the “caller
function” and B is called the “called function or callee function”. Also,
the arguments which A sends to B are called actual arguments and the
parameters of B are called formal arguments.
Terminology
 Formal Parameter : A variable and its type as they appear in the
prototype of the function or method.
 Actual Parameter : The variable or expression corresponding to a
formal parameter that appears in the function or method call in the
calling environment.
Two methods of Parameter Passing:
1.Pass By Value
Pass by reference

1.Pass By Value: in this method Changes made to formal

parameter do not get transmitted back to the formal parameters. Any
modifications to the formal parameter variable will not effect the
actual parameter. This method is also called as call by value.

Program:
 Output:

Pass by reference(aliasing): .. Any changes to the formal

parameter will effect the actual parameter as formal parameter
receives a reference (or pointer). This method is also called as call
by reference.

Program:(passing pointers to function)

Output:

Passing arrays to function

If you want to pass a single-dimension array as an argument in a function,

you would have to declare a formal parameter in one of following three
ways and all three declaration methods produce similar results because
each tells the compiler that an integer pointer is going to be received.
Similarly, you can pass multi-dimensional arrays as formal parameters.
Way-1
Formal parameters as a pointer −
void myFunction (int *arrayname)
{
.
.
.
}
Way-2
Formal parameters as a sized array −
Void myFunction (int arrayname[10])
{
.
.
.
}
Way-3
Formal parameters as an unsized array −
void myFunction (int arrayname[ ])
{
.
.
.
}
Program:
#include<stdio.h>

Void fun(int a[])

Printf(“%d %d %d %d”,a[0],a[1],a[2],a[3]);
}

Void main

Int a[]={10,20,30,40};

fun(a);

Output:

10 20 30 40

Signature of function

Program:

int myFun(char a[ ], int b)

{
printf("%s,%d\n”,a,b);
return 0;
}
int main()
{
myFun ("madhu", 3);
myFun ("naveen", 14);
myFun ("yashwant", 30);
return 0;
}
Output:
madhu,3
Naveen,14
Yashwant,30
 Recursion
Recursion is the technique of making a function call itself. This
technique provides a way to break complicated problems down
into simple problems which are easier to solve.

Recursion is the process of repeating items in a self-similar way. In

programming languages, if a program allows you to call a function inside
the same function, then it is called a recursive call of the function.
Example:
void recursion()
{
recursion(); /* function calls itself */
}

void main()
{
recursion();
}
The C programming language supports recursion, i.e., a function to call
itself. But 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.

Number Factorial:

The following example calculates the factorial of a given number using a

recursive function –
Program:
#include <stdio.h>

int factorial(int n)
{

if(n <= 1)
{
return 1;
}
else return n * factorial(n - 1);
}

int main()
{
int n = 12;
printf("Factorial of %d is %d\n",ni, factorial(n));
return 0;
}

Output:
Factorial of 12 is 479001600

Fibonacci Series:
The following example generates the Fibonacci series for a given number
using a recursive function –
Program:
#include <stdio.h>

int fibonacci(int i)
{

if(i == 0)
{
return 0;
}

else if(i == 1)
{
return 1;
}
else
return fibonacci(i-1) + fibonacci(i-2);
}

int main()
{

int i;

for (i = 0; i < 10; i++)

{
printf("%d\t\n", fibonacci(i));
}

return 0;
}
Output:
0
1
1
2
3
5
8
13
21
34

Disadvantages (or) limitations of Recursion

1)More use of Memory:
As in the process of recursion, the function has to call itself, each other,
and add to the stack in each recursive call and they keep their value
there until the call is finished. In this process, recursion uses lots of
memories.
2)Recursion can be slow:
If it is not implemented properly then it is a very slow process. And it is
a very difficult task to write a recursive function with much less speed
and low memory. The reason behind its being slow is that it requires the
allocation of a new stack frame.
3)Difficult to analyze code:
Recursion is the process of converting a complex problem into less
complex but analyzing code is also a complex part. Sometimes it is very
difficult to understand code.
Comparison Table for Advantages and
Disadvantages of a Recursion

Advantages Disadvantages

Solve problem which is

Slower than nonrecursive function
naturally recursive.
Reduce unnecessary calling of
Requires lots of memory
function

Not more effective in terms of space and

Reduce the length of code
time

Help in solving data structure

Hard to analyze code
problems

Computer runs out of memory if recursive

Stack evolution and infix
calls are not properly checked.
 Dynamic memory allocation in C
Since C is a structured language, it has some fixed rules for programming.
One of them includes changing the size of an array. An array is a
collection of items stored at contiguous memory locations.

As it can be seen that the length (size) of the array above made is 9. But
what if there is a requirement to change this length (size). For Example,
 If there is a situation where only 5 elements are needed to be entered
in this array. In this case, the remaining 4 indices are just wasting
memory in this array. So there is a requirement to lessen the length
(size) of the array from 9 to 5.
 Take another situation. In this, there is an array of 9 elements with all 9
indices filled. But there is a need to enter 3 more elements in this array.
In this case, 3 indices more are required. So the length (size) of the
array needs to be changed from 9 to 12.
This procedure is referred to as Dynamic Memory Allocation in C.
Therefore, C Dynamic Memory Allocation can be defined as a
procedure in which the size of a data structure (like Array) is changed
during the runtime.

The concept of dynamic memory allocation in c language enables the C

programmer to allocate memory at runtime i.e, during the execution of
program (. Dynamic memory allocation in c language is possible by 4
functions of stdlib.h header file.

1. malloc()
2. calloc()
 3. realloc()
4. free()

Now let's have a quick look at the methods used for dynamic memory allocation.

malloc() allocates single block of requested memory.

calloc() allocates multiple block of requested memory.

realloc() reallocates the memory occupied by malloc() or calloc() functions.

free() frees the dynamically allocated memory.

Function Syntax

malloc() malloc (number *sizeof(int));

calloc() calloc (number, sizeof(int));

realloc() realloc (pointer_name, number * sizeof(int));

free() free (pointer_name);

Malloc:
The malloc() function allocates single block of requested memory.

It doesn't initialize memory at execution time, so it has garbage value

initially.

It returns NULL if memory is not sufficient.

malloc Example program:

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

void main()

char *p;

//memory allocated dynamically

p = malloc( 15 * sizeof(char) );

if(p== NULL )

printf("Couldn't able to allocate memory\n");

else
{

strcpy( p,"nagendra");

printf("Dynamically allocated memory content : %s\n", p );

free(p);

Output:

Dynamically allocated memory content : nagendra

Calloc:
The calloc() function allocates multiple block of requested memory.

It initially initialize all bytes to zero.

It returns NULL if memory is not sufficient.

Calloc example program:

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

void main()
{
char *p;
//memory allocated dynamically
p = calloc( 15 , sizeof(char) );

if(p== NULL )
{
printf("Couldn't able to allocate memory\n");
}
else
{
strcpy( p,"nagendra");
}

printf("Dynamically allocated memory content : %s\n", p );

free(p);
}

Output:

Dynamically allocated memory content : nagendra

Realloc:
If memory is not sufficient for malloc() or calloc(), you can reallocate the
memory by realloc() function. In short, it changes the memory size.
Example program for realloc:

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

void main()
{
char *p;
//memory allocated dynamically
p = calloc( 15 , sizeof(char) );
p=realloc(p,100*sizeof(char));

if(p== NULL )
{
printf("Couldn't able to allocate memory\n");
}
else
{
strcpy( p,"nagendra");
}
 printf("Dynamically allocated memory content : %s\n", p );
free(p);
}

Output:

Dynamically allocated memory content : nagendra

free() :

The memory occupied by malloc() or calloc() functions must be released by

calling free() function. Otherwise, it will consume memory until program
exit.
Algorithm for factorial of given number:
Factorial of a positive integer n is product of all values from n to 1. For
example, the factorial of 3 is (3 * 2 * 1 = 6).

Algorithm

Algorithm of this program is very easy −

START
Step 1 → Take integer variable A
Step 2 → Assign value to the variable
Step 3 → From value A upto 1 multiply each digit and store
 Step 4 → the final stored value is factorial of A
STOP
Algorithm to check number is even or odd

Algorithm to check number is prime or not:

A number that is divisible only by 1 and itself is called a prime number..
For example −
7=1×7
Few prime number are − 1, 2, 3, 5 , 7, 11 etc.
Algorithm:
Algorithm, flowchart and C program to find the roots of a
quadratic equation:

Analysis

Input − a,b,c values

Output − r1, r2 values

Algorithm:

 Start
 Read a, b, c values
 Compute d = b*b-4ac
 if d > 0 then
o r1 = -b+ sqrt(d)/(2*a)
o r2 = -b-sqrt(d)/(2*a)
 Otherwise if d = 0 then
o compute r1 = -b/2a, r2=-b/2a
o print r1,r2 values
 Otherwise if d < 0 then print roots are imaginary
 Stop
Program:

# include<stdio.h>
# include<conio.h>
# include<math.h>
main (){
float a,b,c,r1,r2,d;
printf (“enter the values of a b c”);
scanf (“ %f %f %f”, &a, &b, &c);
d= b*b – 4*a*c;
if (d>0)
{
r1 = -b+sqrt (d) / (2*a);
r2 = -b-sqrt (d) / (2*a);
printf (“The real roots = %f %f”, r1, r2);
}
else if (d= =0)
{
r1 = -b/(2*a);
r2 = -b/(2*a);
printf (“roots are equal =%f %f”, r1, r2);
}
else
printf(“Roots are imaginary”);
getch ();
}

Testing:

Case 1: enter the values of a b c: 1 4 3

r1 = -1
r2 = -3
Algorithm for find minimum and maximum element in given list
Various complexities

Asymptotic notations
DIVIDE AND CONQUER STRATEGY
 Searching techniques
Searching refers to the process of finding a desired element in set of
items. The desired element is called "target".
Searching Algorithms :
1. Linear Search
2. Binary Search

Linear search
Linear search is a very simple search algorithm. In this type of search, a
sequential search is made over all items one by one. Every item is
checked and if a match is found then that particular item is returned,
otherwise the search continues till the end of the data collection.

Example:
Algorithm:
Linear Search ( Array Arr, Value a ) // Arr is the name of the array, and a
is the searched element.
Step 1: Set i to 0 // i is the index of an array which starts from 0
Step 2: if i > n then go to step 7 // n is the number of elements in array
Step 3: if Arr[i] = a then go to step 6
Step 4: Set i to i + 1
Step 5: Goto step 2
Step 6: Print element a found at index i and go to step 8
Step 7: Print element not found
Step 8: Exit

Binary search
Difference between linear and binary search
 Sorting
A sorting algorithm is used to arrange elements of an array/list in a
specific order. For example,
 Sorting an
array
Here, we are sorting the array in ascending order.
There are various sorting algorithms that can be used to complete this
operation. And, we can use any algorithm based on the requirement.

Bubble Sort Algorithm:

Bubble Sort is the simplest sorting algorithm that works by repeatedly
swapping the adjacent elements if they are in the wrong order. This
algorithm is not suitable for large data sets as its average and worst-
case time complexity is quite high.

Algorithm:

In the algorithm given below, suppose arr is an array of n elements. The

assumed swap function in the algorithm will swap the values of given
array elements.

1. begin BubbleSort(arr)
2. for all array elements
3. if arr[i] > arr[i+1]
4. swap(arr[i], arr[i+1])
5. end if
6. end for
7. return arr
8. end BubbleSort
 Insertion sort :
Insertion sort is a simple sorting algorithm that works similar to the way
you sort playing cards in your hands. The array is virtually split into a
sorted and an unsorted part. Values from the unsorted part are picked
and placed at the correct position in the sorted part.

Characteristics of Insertion Sort:

 This algorithm is one of the simplest algorithm with simple
implementation
 Basically, Insertion sort is efficient for small data values
 Insertion sort is adaptive in nature, i.e. it is appropriate for data sets
which are already partially sorted.
 Algorithm
 // Sort an arr[] of size n
 insertionSort(arr, n)
 Loop from i = 1 to n-1.
 a) Pick element arr[i] and insert it into sorted sequence arr[0 1
2 ..i-1]
  Example:

SELECTION SORT:

The selection sort algorithm sorts an array by repeatedly finding the

minimum element (considering ascending order) from unsorted part and
putting it at the beginning. The algorithm maintains two sub arrays in a
given array.
 The subarray which is already sorted.
 Remaining subarray which is unsorted.
In every iteration of selection sort, the minimum element (considering
ascending order) from the unsorted subarray is picked and moved to the
sorted subarray.

Selection sort is generally used when -

o A small array is to be sorted

o Swapping cost doesn't matter
o It is compulsory to check all elements
o
o ALGORITHM:
 o Step 1 − Set MIN to location 0
o Step 2 − Search the minimum element in the list
o Step 3 − Swap with value at location MIN
o Step 4 − Increment MIN to point to next element
o Step 5 − Repeat until list is sorted

EXAMPLE :

DIFFERENCE BETWEEN INSERTION SORT AND SELECTION SORT

Insertion Sort Selection Sort

Finds the minimum / maximum
Inserts the value in the presorted array to sort the set number from the list and sort it
1. of values in the array. in ascending / descending order.

It is an unstable sorting
2. It is a stable sorting algorithm. algorithm.

The best-case time complexity is Ω(N) when the For best case, worst case and
array is already in ascending order. It have Θ(N2) in average selection sort have
3. worst case and average case. complexity Θ(N2).

The number of comparison operations performed in The number of comparison

this sorting algorithm is less than the swapping operations performed in this
4. performed. sorting algorithm is more than
 Insertion Sort Selection Sort
the swapping performed.

It is less efficient than the

5. It is more efficient than the Selection sort. Insertion sort.

The location where to put the

element is previously known we
Here the element is known beforehand, and we search for the element to insert
6. search for the correct position to place them. at that position.

The selection sort is used when

 A small list is to be sorted
 The cost of swapping does not
matter
 Checking of all the elements is
compulsory
 Cost of writing to memory
matters like in flash memory
The insertion sort is used when: (number of Swaps is O(n) as
 The array is has a small number of elements compared to O(n2) of bubble
7.  There are only a few elements left to be sorted sort)

The insertion sort is Adaptive, i.e., efficient for data

sets that are already substantially sorted: the time
complexity is O(kn) when each element in the input
is no more than k places away from its sorted Selection sort is an in-place
8. position comparison sorting algorithm