You are on page 1of 67

What is function????

Function is a self contained block of statements that

perform a coherent task of some kind. Every C program can be a thought of the collection of functions. main( ) is also a function.

Types of Functions.
Library functions These are the in- -built functions of C library. These are already defined in header files. e.g. printf( ); is a function which is used to print at output. It is defined in stdio.h file . User defined functions. Programmer can create their own function in C to perform specific task

Why use functions?

Writing functions avoids rewriting of the same code

again and again in the program. Using function large programs can be reduced to smaller ones. It is easy to debug and find out the errors in it. Using a function it becomes easier to write program to keep track of what they are doing.

Function Declaration ret_type func_name(data_type par1,data_type par2);

Function Defination ret_type func_name(data_type par1,data_type par2) { } Function Call func_name(data_type par1,data_type par2);

Function prototype
A prototype statement helps the compiler to check the

return type and arguments type of the function. A prototype function consist of the functions return type, name and argument list. Example
int sum( int x, int y);

#include<iostream.h> #include<conio.h> void main() { clrscr(); void print(); /*func declaration print(); /*func calling printf(no parameter and no return value); print(); getch(); } void print() /*func defination { For(int i=1;i<=30;i++) { Cout<<*; } Cout<<endl; }

#include<conio.h> void main() { clrscr(); int a=10,b=20; int sum(int,int); int c=sum(a,b); /*actual arguments Cout<<sum is << c; getch(); } intsum(int x, int y) /*formal arguments { int s; s=x+y; return(s); /*return value }

Function parameters
The parameters are local variables inside the body of

the function.
When the function is called they will have the values

passed in. The function gets a copy of the values passed in (we will later see how to pass a reference to a variable).

one-to-one correspondence between the

arguments in a function call and the parameters in the function definition.

int argument1; double argument2; // function call (in another function, such as main) result = thefunctionname(argument1, argument2); // function definition int thefunctionname(int parameter1, double parameter2){ // Now the function can use the two parameters // parameter1 = argument 1, parameter2 = argument2

a) Actual arguments:-the arguments of calling function

are actual arguments. b) Formal arguments:-arguments of called function are formal arguments. c) Argument list:-means variable name enclosed within the paranthesis.they must be separated by comma d) Return value:-it is the outcome of the function. the result obtained by the function is sent back to the calling function through the return statement.

Return statement
It is used to return the value to the calling function.
It can be used in fallowing ways a) return(expression) return(a+b); b) A function may use one or more return statement depending upon condition
if(a>b) return(a); else return(b);

c) return(&a); returns the address of the variable d)returns(*p);returns value of variable through the pointer e)return(sqrt(r)); f)return(float (sqrt(2.4)));

Categories of functions
A function without parameter and return value

A function without parameter and no return value

A function with parameter and return value A function with parameter and no return value

A function with no parameter and no return value

#include<conio.h> void main() { clrscr(); void print(); /*func declaration print(); /*func calling Cout<<no parameter and no return value; print(); getch(); } void print() /*func defination { For(int i=1;i<=30;i++) { cout<<*; } Cout<<\n; }

A function with no parameter and no return value

There is no data transfer between calling and called

function The function is only executed and nothing is obtained Such functions may be used to print some messages, draw stars etc

A function with parameter and no return value

#include<conio.h> void main() { clrscr(); int a=10,b=20; void mul(int,int); mul(a,b); getch(); } void mul(int x, int y) { int s; s=x*y; Cout<<mul is << s; }

/*actual arguments

/*formal arguments

A function with parameter and return value

#include<conio.h> void main() { clrscr(); int a=10,b=20,c; int max(int,int); c=max(a,b); Cout<<greatest no is <<c; getch(); } int max(int x, int y) { if(x>y) return(x); else { return(y); } }

A function without parameter and return value

#include<conio.h> void main() { clrscr(); int a=10,b=20; int sum(); int c=sum(); /*actual arguments Cout<<sum is<< c; getch(); } int sum() /*formal arguments { int x=10,y=30; return(x+y); /*return value }

Argument passing techniques

Pass By Value Pass By Reference Pass By Pointer\address

Call By Value
It is a default mechanism for argument passing.
When an argument is passed by value then the copy of

argument is made know as formal arguments which is stored at separate memory location Any changes made in the formal argument are not reflected back to actual argument, rather they remain local to the block which are lost once the control is returned back to calling program

void main() { int a=10,b=20; void swap(int,int); Cout<<before function calling<<a<<b; swap(a,b); Cout<<after function calling<<a<<b; getch(); }

void swap(int x,int y) { int z; z=x; x=y; y=z; Cout<<value is<<x<<y; }

Output: before function calling a=10 b=20 value of x=20 and y= 10 after function calling a=10 b=20

Call By pointer/address
In this instead of passing value, address are passed.
Here formal arguments are pointers to the actual

arguments Hence change made in the argument are permanent.

Void main() { int a=10 ,b=25; void swap(int *,int *); Cout<<before function calling<<a<<b; swap(&a,&b); Cout<<after function calling<<a<<b; getch(); }

void swap(int *x,int *y) { int z; z=*x; *x=*y; *y=z; Cout<<value is<<*x<<*y; }

before function calling a= 10 b= 25 value of x=25 and y=10 after function calling a=25 b= 10

Using Reference Variables with Functions

To create a second name for a variable in a

program, you can generate an alias, or an alternate name

In C++ a variable that acts as an alias for another

variable is called a reference variable, or simply a reference

Declaring Reference Variables

You declare a reference variable by placing a type and

an ampersand in front of a variable name, as in double &cash; and assigning another variable of the same type to the reference variable
double someMoney; double &cash = someMoney;

A reference variable refers to the same memory

address as does a variable, and a pointer holds the memory address of a variable

Pass By Reference
void main() { int i=10; int &j=i; // j is a reference variable of I cout<<value<<i<<\t<<j; j=20; cout<<modified value<<i<<\t<<j; getch(); }

Output:Value 10 10 modified value 20 20


void swap(int &iNum1, int &iNum2); void main() { int iVar1, iVar2; cout<<"Enter two numbers ; void swap(int &iNum1, int cin>>iVar1; &iNum2) cin>>iVar2; { swap(iVar1, iVar2); int iTemp; cout<<"In main "<<iVar1<<iVar2; iTemp = iNum1; } iNum1 = iNum2; iNum2 = iTemp; cout<<"In swap "<<iNum1<<" "<<iNum2<<endl; }

Declaring Reference Variables

variables and pointers:
Pointers are more flexible

There are two differences between reference

Reference variables are easier to use

You assign a value to a pointer by inserting an

ampersand in front of the name of the variable whose address you want to store in the pointer It shows that when you want to use the value stored in the pointer, you must use the asterisk to dereference the pointer, or use the value to which it points, instead of the address it holds

Comparing Pointers and References in a Function Header

Passing Variable Addresses to Reference Variables

Reference variables are easier to use because you dont

need any extra punctuation to output their values

You declare a reference variable by placing an

ampersand in front of the variables name

You assign a value to a reference variable by using

another variables name

The advantage to using reference variables lies in

creating them in function headers

Passing Arrays to Functions

An array name actually represents a memory address
Thus, an array name is a pointer The subscript used to access an element of an array

indicates how much to add to the starting address to locate a value

When you pass an array to a function, you are actually

passing an address
Any changes made to the array within the function

also affect the original array

#include <stdio.h> void main() { void printarr(int [ ]); int a[5]; printf(enter the elements of array); for(int i = 0;i<5;i++) { scanf(%d,&a[i]); } printarr(a); } void printarr(int s[]) { for(int i = 0;i<5;i++) { printf(" %d\n",s[i]); } }

Inline Functions
Each time you call a function in a C++ program, the

computer must do the following:

Remember where to return when the function eventually ends Provide memory for the functions variables

Provide memory for any value returned by the function

Pass control to the function Pass control back to the calling program

This extra activity constitutes the overhead, or cost of

doing business, involved in calling a function

Using an Inline Function

Inline Functions
An inline function is a small function with no calling

overhead Overhead is avoided because program control never transfers to the function A copy of the function statements is placed directly into the compiled calling program The inline function appears prior to the main(), which calls it Any inline function must precede any function that calls it, which eliminates the need for prototyping in the calling function

Inline Functions
When you compile a program, the code for the inline

function is placed directly within the main() function

You should use an inline function only in the

following situations:
When you want to group statements together so that you can

use a function name

When the number of statements is small (one or two lines in

the body of the function)

When the function is called on few occasions

Using Default Arguments

When you dont provide enough arguments in a function

call, you usually want the compiler to issue a warning message for this error
Sometimes it is useful to create a function that supplies a

default value for any missing parameters

Using Default Arguments

Two rules apply to default parameters:

If you assign a default value to any variable in a function prototypes

parameter list, then all parameters to the right of that variable also must have default values
If you omit any argument when you call a function that has default

parameters, then you also must leave out all arguments to the right of that argument

Examples of Legal and Illegal Use of Functions with Default Parameters

When function call itself repeatedly ,until some

specified condition is met then this process is called recursion. It is useful for writing repetitive problems where each action is stated in terms of previous result. The need of recursion arises if logic of the problem is such that the solution of the problem depends upon the repetition of certain set of statements with different input values an with a condition.

Two basic requirements for recursion :

1. The function must call itself again and again.

2. It must have an exit condition.

Factorial using recursion

void main() { clrscr(); int rect(int); int n,fact; Cout<<enter the no.; cin>>n; fact=rect(n); Cout<<factorial is<<fact; getch(); }

int rect(int a) { int b; if(a==1) { return(1); } else { b=a*rect(a-1); return(b); } }

Stack representation
. . 3*Rec(2) 3*2*Rec(1) 3*Rec(2) Rec(3)



3*2*1 3*2*Rec(1) 3*Rec(2) Rec(3)

Advantages of recursion
1. It make program code compact which is easier to

write and understand. 2. It is used with the data structures such as linklist,stack,queues etc. 3. It is useful if a solution to a problem is in repetitive form. 4. The compact code in a recursion simplifies the compilation as less number of lines need to be compiled.

1. Consume more storage space as recursion calls and

automatic variables are stored in a stack. 2. It is less efficient in comparison to normal program in case of speed and execution time 3. Special care need to be taken for stopping condition in a recursion function 4. If the recursion calls are not checked ,the computer may run out of memory.

Pointer to Function
Function pointers are pointers, i.e. variables, which

point to the address of a function. The syntax to declare to declare a function pointer is as follows: [return_type] (*pointer_name)[(list_of_parameters)] example: Function declaration int add(int ,int); Pointer declaration int(*ptr)(int,int); Assigning address of the function to pointer ptr=add;


#include<iostream.h> #include<conio.h> Void main() { clrscr(); int x=3,y=5,z; int add(int , int); int (*ptr)(int,int); ptr=add; z=(*ptr)(x,y); Cout<<result is <<z; getch(); }

int add(int x,int y) { return(x+y); }


The word polymorphism is derived from Greek word

Poly which means many and morphos which means forms. Polymorphism can be defined as the ability to use the same name for two or more related but technically different tasks. Eg-woman plays role of daughter,sister,wife,mother etc.

Overloading in C++
What is overloading

Overloading means assigning multiple meanings to a function name or operator symbol It allows multiple definitions of a function with the same name, but different signatures. C++ supports Function overloading Operator overloading

Why is Overloading Useful? Function overloading allows functions that

conceptually perform the same task on objects of different types to be given the same name.
Operator overloading provides a convenient

notation for manipulating user-defined objects with conventional operators.

Function Overloading

Is the process of using the same name for two or more

functions Requires each redefinition of a function to use a different function signature that is:
different types of parameters, or sequence of parameters,

or number of parameters

Is used so that a programmer does not have to

remember multiple function names

Function Overloading
Two or more functions can have the same name but

different parameters Example:

int max(int a, int b) { if (a>= b) return a; else return b; } float max(float a, float b) { if (a>= b) return a; else return b; }

Overloading Function Call Resolution

Overloaded function call resolution is done by

compiler during compilation The function signature determines which definition is used a Function signature consists of: Parameter types and number of parameters supplied to a function a Function return type is not part of function signature and is not used in function call resolution

Void sum(int,int); Void sum(double,double); Void sum(char,char); Void main() { int a=10,b=20 ; double c=7.52,d=8.14; char e=a , f=b ; sum(a,b); sum(c,d); sum(e,f); }

Void sum(int x,int y) { Cout<<\n sum of integers are<<x+y; } Void sum(double x,double y) { Cout<<\n sum of two floating no are<<x+y; } Void sum(char x,char y) { Cout<<\n sum of characters are<<x+y; }


Sum of integers 30 sum of two floating no are 15.66 sum of characters are 195