Professional Documents
Culture Documents
Lec21 22
Lec21 22
Lec 21-22
Types of Polymorphism
• Compile time
– Uses static or early binding.
– Example:
Function overloading and Operator overloading.
• Run time
– Uses dynamic or late binding.
– Example:
Virtual functions.
Run-time Polymorphism
Pointers to Derived Classes
• Base class pointers can point to derived class
objects.
• Example: Let there be two classes,
– class base { … };
– class derived : public base { … };
• Then,
base *p1;
derived d_obj;
p1 = &d_obj;
Contd…
• A base class pointer pointing to a derived class
object
– Has knowledge only of the base class.
– Knows nothing about the members added by the
derived class.
• Thus,
– Members of the derived object that were
inherited from the base class can only be
accessed.
Example
1. #include<iostream> 13. int main()
2. using namespace std; 14. { base b1;
3. class base { 15. b1.show(); // base
4. public: 16. derived d1;
5. void show() 17. d1.show(); // derived
6. { cout << "base\n"; } 18. base *pb = &b1;
7. }; 19. pb->show(); // base
8. class derived : public base { 20. pb = &d1;
9. public: 21. pb->show(); // base
10. void show() 22. }
11. { cout << "derived\n"; }
12. };
Virtual Functions
• A member function declared within a base class
are redefined by a derived class. (Overriding)
• Implement the "one interface, multiple methods"
philosophy that underlies polymorphism.
• The keyword virtual is used to designate a member
function as virtual.
• Support run-time polymorphism with the help of
base class pointers.
Contd…
• While redefining a virtual function in a derived
class,
– The function signature must match the original
function present in the base class.
– The keyword virtual is not needed (but can be
specified).
• The "virtual"-ity of the member function continues
along the inheritance chain.
• A class that contains a virtual function is referred to
as a polymorphic class.
Example – 1
1. #include<iostream> 13. int main()
2. using namespace std; 14. { base b1;
3. class base { 15. b1.show(); // base
4. public: 16. derived d1;
5. virtual void show() 17. d1.show(); // derived
6. { cout << "base\n"; } 18. base *pb = &b1;
7. }; 19. pb->show(); // base
8. class derived : public base { 20. pb = &d1;
9. public: 21. pb->show(); // derived
10. void show() 22. }
11. { cout << "derived\n"; }
12. };
Example – 2
1. #include<iostream> 15. int main()
2. using namespace std; 16. { base *pb;
3. class base {
17. d1 od1;
4. public:
5. virtual void show() 18. d2 od2;
6. { cout << "base\n"; } }; 19. int n;
7. class d1 : public base { 20. cin >> n;
8. public: 21. if (n % 2)
9. void show() 22. pb =
10. { cout << "derived – 1\n"; } };
&od1;
11. class d2 : public base {
12. public: 23. else
13. void show() 24. pb =
14. { cout << "derived – 2\n"; } }; &od2;
Virtual Destructors
• Constructors cannot be virtual, but destructors can
be virtual.
class A
{ virtual void disp()= 0;
};
class B: public class A
{ virtual void disp() = 0;
};
#include <iostream> class C: public B
using namespace std; { public:
void disp()
class A {cout<<"Welcome";}
{ public: };
virtual void disp()= 0;
}; int main()
class B: public A { C obj;
{ public: obj.disp();
virtual void disp() = 0; return 0;
}; }
Pointer to Abstract Class
#include <iostream>
using namespace std; int main()
{ A *p;
class A C obj;
{ public: p= &obj;
virtual void disp()= 0; p->disp();
}; return 0;
class C: public A }
{ public:
void disp()
{cout<<"Welcome";} OUTPUT
}; Welcome
Applying Polymorphism
• Early binding
– Normal functions, overloaded functions.
– Nonvirtual member and friend functions.
– Resolved at compile time.
– Very efficient.
– But lacks flexibility.
• Late binding
– Virtual functions accessed via a base class pointer.
– Resolved at run-time.
– Quite flexible during run-time.
– But has run-time overhead; slows down program
execution.