4. Function overloading:
An overloaded function can have multiple
definitions for the same function name in the same
scope.
Function declarations cannot be
overloaded if they differ only by return type.
Operator overloading:
It is one of the many exciting features of
c++.
important technique that has enhanced
the power of extensibility of c++.
Virtual functions:
we use pointer to base class to refer to
all the derived objects.
5. INTRODUCTION POLYMORPHISM IN
C++
Polymorphism is one of the crucial features of oop.
Polymorphism divide in 2 types
Compile time
Run time
Compile time Polymorphism
Uses static or early binding
Ex. Function and operator overloading
Run time Polymorphism
Uses Dynamic or early binding
EX.Virtual Functions
6. COMPILE TIME POLYMORPHISM
Function overloading is an example of
compile time polymorphism
This decision of binding among several
function is taken by considering formal
arguments of the function , their data type
and their sequence.
7. RUN TIME POLYMORPHISM
It is also known as dynamic binding, late binding
and overriding as well
It provides slow execution as compare to early
binding because it is known at run time
Run time polymorphism is more flexible as all
things execute at run time.
8. RUN TIME POLYMORPHISM
For Example:
Class A
{
int x;
public:
void show() {…..}
};
class B : public A
{
int y;
public:
void show() {…..}
};
9. POINTERS
Pointer is a derived data type that refers to
another data variable by storing the
variable’s memory address rather than data.
Pointer variable can also refer to (or point to)
another pointer in c++.
10. DECLARING AND INITIALIZING
POINTERS
The declaration is based on the data type of the
variable it points to.
The declaration is based on the data type of the
variable takes the following form
Syntax:
data-type *pointer –variable;
Let us declare a pointer variable, which points to an
integer variable
Int * ptr;
we can initialize a pointer
Int* ptr ,a; // declaration
Ptr=&a; // initialization
11. EXAMPLE OF USING POINTERS
#include <iostream.h>
#include <conio.h>
Void main()
{
Int a,*ptr1,**ptr2;
Clrscr();
Ptr1=&a;
Ptr2=&ptr1;
cout <<“The address of a :”<<ptr1<<“n”;
C 0ut <<“The address of ptr1 :”<<ptr2;
Cout <<“nn”;
Cout <<“after incrementing the address values:n”;
Ptr1+=2;
cout <<“The address of a :”<<ptr1<<“n”;
Ptr2+=2;
Cout <<“The address of ptr1 :”<<ptr2<<“n”;
}
Output:
The address of a:0xfb6fff4
The address of ptr1:ox8fb6ff2
After incrementing the address values:
The address of a:ox8fb6fff8
The address of a:ox8fb6fff6
12. MANIPULATION OF POINTERS
We can manipulate a pointer with the
indirection operator ,i.e.,’*’which is also
known as dereference operator.
Syntax:
*pointer_variable
13. MANIPULATE OF POINTERS
#include<iostream.h>
#include<conio.h>
Int main()
{
Int a=10;
Int *ptr;
Clrscr();
Ptr=&a;
Cout<<“the value of a is:”<<*ptr;
*ptr=*ptr+a; // manipulate
Cout<<n the revised value of a is”<<a;
getch ();
return o;
}
Output:
The value of a is:10
The revised value of a
is:20
14. POINTER EXPRESSIONS AND POINTER
ARITHMETIC
A pointer can be incremented(++) or decremented(--)
Any integer can be added to or subtracted from a pointer
One pointer can be subtracted from another
Example:
int a[6];
int *aptr;
aptr=&a[0];
We can increment the pointer variable
aptr++ (or) ++aptr
We can decrement the pointer variable
aptr-- (or) --aptr
15. USING POINTERS WITH ARRAY AND
STRINGS
Pointer is one of the efficient tools to access
elements of an array.
We can declare the pointers to array
Int *nptr;
nptr=number[0];
nptr points to the first element of the integer
array, number[0].
float*fptr;
fptr=price[0];
16. ARRAY OF POINTERS
The array of pointers represents a collection
of addresses.
An array of pointers point to an array of data
items.
We can declare an array of pointers as
int *inarray[10];
17. PROGRAM ARRAY OF POINTER
#include<iostream.h>
Const int MAX=4;
Int main()
{
Char*names[100]={“priya”,”nathiya”,”riya”,”sri”,”chitra”};
For (int i=0;i<100;i++)
{
Cout<<“value of names[“<<i<<“]=“;
Cout<<names[i]<<endI;
}
return 0;
}
18. POINTER AND STRINGS
There are two ways to assign a value to a
string
We can use the character array or variable
of type char*.
char num[]=“one”;
const char*numptr=“one”;
19. THIS POINTER
This unique pointer is automatically passed to a
member function when it is called
The pointer this acts as an implicit argument to
all the member functions
This pointer is an implicit parameter to all
member functions.
20. EXAMPLE FOR THIS POINTER
Class className
{
Private:
int dataMember;
Public:
Method(int a)
{
//This pointer stores the address of object obj and access dataMemberThis -> dataMember=a;
… … ..
}
}
int main()
{
className obj;
Obj.method(5);
….. … …
}
21. Pointers to objects of a base class are type
compatiable with pointers to objects of a
derived class
A single pointer variable can be made to point
to objects belonging to different classes.
POINTER TO DERIVED CLASS
22. VIRTUAL FUNCTIONS
A virtual function is a member function of class
that is declared within a base and re-defined in
derived class.
Syntax:
virtual return_type function_name()
{
……..
……..
}
23. RULES OF VIRTUAL FUNCTIONS
Virtual functions are created for implementing
late binding
The virtual functions must be members of
some class .
They cannot be static members.
They are accessed by using object pointers.
A virtual function can be a friend of another
class.
24. Difference between virtual and pure
virtual Functions
BASIS FOR
COMPARISON
VIRTUAL FUNCTION PURE VIRTUAL FUNCTION
Base ‘virtual function’
has their definition
in the base class
‘pure virtual function’ has no
definition in the base class.
Declaration Funct_name(parame
ter_list){….};
Virtual
funct_name(parameter_list)=0;
Derived class All derived classes
may or may not
override the virtual
function of the base
class
All derived classes must
override the virtual
function of the base class.
25. PURE VIRTUAL FUNCTIONS
A function virtual inside the base class and
redefine it in the derived classes.
for ex. we have not defined any object of
class media and therefore the function
display().
The base class has been defined ‘empty’.
Virtual void display()=0;
26. PURE VIRTUAL FUNCTION REAL
WORLD EXAMPLE
int main()
{
Shape*sptr;
Rectangle rect;
Sptr=& ret;
Sptr->set_data (5,3);
Cout<<“area of rectangle is”<<sptr->area()<<endl;
Trangle tri;
Sptr=&tri;
Sptr->set_data(4,6);
Cout<<“area of triangle is”<<sptr->area()<<endLl;
Return 0;
}
27. VIRTUAL CONSTRUCTORS AND DESTRUCTOR
“A constructor can not be virtual “.there are some valid reasons that justify this statement
First to create an object the constructor of the object class must be of the same type as the class.
Class declarations that make use of destructors
class A
{
public:
~a()
{
// base class destructor
}
};
class B:publicA
{
public:
~b()
{
//derived class destructor
}
};
Main()
{
A* ptr=new B();
.
.
Delete ptr;
}
28. We must declare the base class destructor
Class A
{
Public:
Virtual ~A()
{
// base class destructor
}
};
