course title : oop using c++
DESCRIPTION
Course Title : OOP Using C++. Chapter No: 04. Chapter No: 04. COURSE INSTRUCTOR : ILTAF MEHDI. Polymorphism. The word polymorphism is a combination of two words poly and Morphism. - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/1.jpg)
Ch
apte
r N
o: 0
4
1
Ch
apte
r N
o: 0
4
By ILTAF MEHDI, IT LECTURER, MIHE, KATR-E-PARWAN BRANCH, KABUL
![Page 2: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/2.jpg)
The word polymorphism is a combination of two words poly and Morphism.
Poly means many and Morphism means form. In OOP polymorphism is the ability of objects of different types of respond to functions of the same name. the user does not have know the exact type of the object in advance.
The behavior of the object can be implemented at the run time. It is called late binding or dynamic binding. Polymorphism is implemented by using virtual function.
![Page 3: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/3.jpg)
It is one of the outstanding feature of OOP.
In it objects of different classes related by inheritance receive a same message (function call) and respond differently.
One interface & multiple methods. One thing having different shapes
![Page 4: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/4.jpg)
A pointer can also refers to an object of a class. The member of an object can be accessed through pointers by the symbol ->
The saymbol is known as member access operator.
Syntax ; ptr -> member
![Page 5: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/5.jpg)
#include <iostream.h> #include <conio.h> class Test { private: int *n; public: void in(void); { cout <<“enter number”;
cin>>n; }
void out(void);
{
cout <<“the value of n: “<<n<<endl;
cout <<“address”<<&n<<endl;
} };
Void main(void) { clrscr(); Test *ptr; ptr = new Test; ptr -> in(); ptr->out(); getch(); }
![Page 6: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/6.jpg)
POLYMORPHISM
class drawing{public:void draw() { ----------}};
Class ball:public drawing{ public: ---------- void draw() { --------} };
Class ball:public drawing{ public: ---------- void draw() { --------} };
void main(){ball objball;rect objrect;P=&objball; pdraw(); pdraw();P=&objrect; pdraw(); pdraw();}
Class rect:public drawing{ public: void draw() {--------} };
Class rect:public drawing{ public: void draw() {--------} };
EARLY BINDING
class drawing{public:virtual void draw()=0 { ----------}};
class drawing{public:virtual void draw()=0 { ----------}};
Pure Virtual Function
LATE BINDING
![Page 7: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/7.jpg)
ABSTRACT CLASS A class having one or more pure virtual function is called
Abstract class. Object of the abstract class can not be created .
CONCRETE CLASS
A class having no pure virtual function is called Concrete class.
Object of the concrete class can be created .
![Page 8: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/8.jpg)
In principle, private and protected members of a class cannot be accessed from outside the same class in which they are declared. However, this rule does not affect friends.
Friends are functions or classes declared as such.
If we want to declare an external function as friend of a class, thus allowing this function to have access to the private and protected members of this class, we do it by declaring a prototype of this external function within the class, and preceding it with the keyword friend.
![Page 9: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/9.jpg)
#include <iostream>
class CRectangle {
int width, height;
public:
void set_values (int, int);
int area () {return (width * height);}
friend CRectangle duplicate (CRectangle);
};
void CRectangle::set_values (int a, int b)
{
width = a;
height = b;
}
CRectangle duplicate (CRectangle rectparam){CRectangle rectres;rectres.width = rectparam.width*2;rectres.height = rectparam.height*2;return (rectres);}int main () {CRectangle rect, rectb;rect.set_values (2,3);rectb = duplicate (rect);cout << rectb.area();return 0;}
![Page 10: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/10.jpg)
#include <iostream.h> class CSquare; class Crectangle { int width, height; public: int area () { return (width * height);} void convert (CSquare a); }; class CSquare { private: int side; public: void set_side (int a) {side=a;} friend class CRectangle; };
void CRectangle::convert (CSquare a) { width = a.side; height = a.side;}int main () { CSquare sqr; Crectangle rect; sqr.set_side(4); rect.convert(sqr); cout << rect.area();return 0;}
![Page 11: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/11.jpg)
11
Class Interface Diagram
Protected data:
hrs
mins
secs
ExtTime class
Set
Increment
Write
Time
Time
Set
Increment
Write
ExtTime
ExtTime
Private data:zone
Time class
![Page 12: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/12.jpg)
When the type of a formal parameter is a parent class, the argument used can be:
the same type as the formal parameter,
or,
any derived class type.
Static binding is the compile-time determination of which function to call for a particular object based on the type of the formal parameter
When pass-by-value is used, static binding occurs
12
![Page 13: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/13.jpg)
Is the run-time determination of which function to call for a particular object of a derived class based on the type of the argument
Declaring a member function to be virtual instructs the compiler to generate code that guarantees dynamic binding
Dynamic binding requires pass-by-reference
13
![Page 14: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/14.jpg)
// SPECIFICATION FILE ( time.h )
class Time{
public :
. . .
virtual void Write ( ) ; // for dynamic bindingvirtual ~Time(); // destructor
private :
int hrs ; int mins ; int secs ;
} ;
14
![Page 15: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/15.jpg)
void Print (Time * someTime ) {
cout << “Time is “ ;someTime->Write ( ) ;cout << endl ;
}
15
CLIENT CODE
Time startTime( 8, 30, 0 ) ; ExtTime endTime(10, 45, 0, CST) ;
Time *timeptr;timeptr = &startTime;Print ( timeptr ) ;
timeptr = &endTime;Print ( timeptr ) ;
OUTPUT
Time is 08:30:00 Time is 10:45:00 CST
Time::write()
ExtTime::write()
![Page 16: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/16.jpg)
Virtual Functions overcome the problem of run time object determination
Keyword virtual instructs the compiler to use late binding and delay the object interpretation
How ? Define a virtual function in the base class. The word virtual appears
only in the base class If a base class declares a virtual function, it must implement that
function, even if the body is empty Virtual function in base class stays virtual in all the derived classes It can be overridden in the derived classes But, a derived class is not required to re-implement a virtual
function. If it does not, the base class version is used
16
![Page 17: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/17.jpg)
Some classes exist logically but not physically. Example : Shape
Shape s; // Legal but silly..!! : “Shapeless shape” Shape makes sense only as a base of some classes derived from it.
Serves as a “category” Hence instantiation of such a class must be prevented
17
class Shape //Abstract { public : //Pure virtual Function virtual void draw() = 0;}
A class with one or more pure virtual functions is an Abstract Class
Objects of abstract class can’t be
createdShape s; // error : variable of an abstract class
![Page 18: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/18.jpg)
18
Shape
virtual void draw()
Circle
public void draw()
Triangle
public void draw()
![Page 19: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/19.jpg)
A pure virtual function not defined in the derived class remains a pure virtual function.
Hence derived class also becomes abstract
19
class Circle : public Shape { //No draw() - Abstractpublic :void print(){ cout << “I am a circle” << endl;}
class Rectangle : public Shape {public :void draw(){ // Override Shape::draw() cout << “Drawing Rectangle” << endl;}Rectangle r; // Valid
Circle c; // error : variable of an abstract class
![Page 20: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/20.jpg)
When you use virtual functions, compiler store additional information about the types of object available and created
Polymorphism is supported at this additional overhead Important :
virtual functions work only with pointers/referenceswith objects even if the function is virtual If a class declares any virtual methods, the destructor of the
class should be declared as virtual as well.
20
![Page 21: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/21.jpg)
Pure virtual functions are useful because they make explicit the abstractness of a class
Tell both the user and the compiler how it was intended to be used
Note : It is a good idea to keep the common code as close as possible to the root of you hierarchy
21
![Page 22: Course Title : OOP Using C++](https://reader036.vdocument.in/reader036/viewer/2022062422/568133a9550346895d9ab8fb/html5/thumbnails/22.jpg)
It is still possible to provide definition of a pure virtual function in the base class
The class still remains abstract and functions must be redefined in the derived classes, but a common piece of code can be kept there to facilitate reuse
In this case, they can not be declared inline
22
class Shape { //Abstract public : virtual void draw() = 0;};
// OK, not defined inline void Shape::draw(){ cout << “Shape" << endl;}
class Rectangle : public Shape
{ public : void draw(){ Shape::draw(); //Reuse cout <<“Rectangle”<< endl;}