POLYMORPHISM
Polymorphism
Compile-time binding ( Static binding )
Compile-time binding is to associate a function’s
name with the entry point of the function at
compile time.
Example:
#include <iostream>
using namespace std;
void sayHi();
int main(){
sayHi(); // the compiler binds any invocation of sayHi()
// to sayHi()’s entry point.
}
void sayHi(){
cout << ‘‘Hello, World!\n’’;
}
In C, only compile-time binding is provided.
In C++, all non-virtual functions are bound at
compile-time.
1
Polymorphism
Run-time binding ( Dynamic binding )
• Run-time binding is to associate a function’s name
with the entry point at run-time.
• C++ supports run-time binding through virtual
functions.
• Polymorphism is thus implemented by virtual
functions and run-time binding mechanism in
C++. A class is called polymorphic if it
contains virtual functions.
2
Polymorphism
A typical scenario of polymorphism in C++:
• There is an inheritance hierarchy
• The first class that defines a virtual function is the
base class of the hierarchy that uses dynamic
binding for that function name and signature.
• Each of the drived classes in the hierarchy must
have a virtual function with same name and
signature.
• There is a pointer of base class type; and this
pointer is used to invoke virtual functions of
derived class.
3
Polymorphism
Example:
#include <iostream>
using namespace std;
class Shape{
public:
virtual void sayHi() { cout <<‘‘Just hi! \n’’;}
};
class Triangle : public Shape{
public:
virtual void sayHi() { cout <<‘‘Hi from a triangle! \n’’;}
};
class Rectangle : public Shape{
public:
virtual void sayHi() { cout <<‘‘Hi from a rectangle! \n; }
};
int main(){
Shape *p;
int which;
cout << ‘‘1 -- shape, 2 -- triangle, 3 -- rectangle\n ’’;
cin >> which;
switch ( which ) {
case 1: p = new Shape; break;
case 2: p = new Triangle; break;
case 3: p = new Rectangle; break;
}
p -> sayHi(); // dynamic binding of sayHi()
delete p;
}
4
Polymorphism
Virtual Functions
• To declare a function virtual, we use the Keyword
virtual.
class Shape{
public:
virtual void sayHi (){ cout <<‘‘Just hi! \n’’;}
};
• If the member function definition is outside the
class, the keyword virtual must not be specified
again.
class Shape{
public:
virtual void sayHi ();
};
virtual void Shape::sayHi (){ // error
cout << ‘‘Just hi! \n’’;
}
• Virtual functions can not be stand-alone functions
or static methods.
5
Polymorphism
• A virtual function can be used same as non-virutal
member functions.
Example:
class B {
public:
virtual void m() { cout << ‘‘Hello! \n’’; }
};
int main(){
B b_obj;
b_obj.m();
}
• A virtual function can be inherited from a base
class by a derived class, like other class member
functions.
Example:
class B {
public:
virtual void m() { cout << ‘‘Hello! \n’’;}
};
class D : public B{
// inherite B::m()
};
int main(){
D d_obj;
d_obj.m();
}
6
Polymorphism
To let derived classes have their own implementation for
the virtual function. we override base class virtual
functions in derived class.
In order for a derived class virtual function instance to
override the base class virtual function instance, its
signature must match the base class virtual function
exactly.
The overriding functions are virtual automatically. The
use of keyword virtual is optional in derived classes.
Example:
class Shape{
public:
virtual void sayHi() { cout <<‘‘Just hi! \n’’;}
};
class Triangle : public Shape{
public:
// overrides Shape::sayHi(), automatically virtual
void sayHi() { cout <<‘‘Hi from a triangle! \n’’;}
};
7
Polymorphism
Polymorphism
Dynamic binding is enabled when a virtual
function is invoked through a derived class
object which is refered indirectly by either a base
class pointer or reference,
Example:
void print(Shape obj, Shape *ptr, Shape &ref){
ptr -> sayHi(); // bound at run time
ref.sayHi(); // bound at run time
obj.sayHi(); // bound at compile time
}
int main(){
Triangle mytri;
print( mytri, &mytri, mytri );
}
Thus, polymorphism in C++ is supported by
using pointers and references.
8
Polymorphism
Exercise 1:
Is m() bound at compile time or run time ?
Output ?
class B {
public:
void m() { cout << ‘‘B::m \n’’;}
};
class D : public B{
public:
void m() { cout << ‘‘D::m \n’’;}
};
int main(){
B *p;
p = new D;
p -> m();
}
9
Polymorphism
Exercise 2:
Is m() bound at compile time or run time ?
Output?
class B {
public:
virtual void m() { cout << ‘‘B::m \n’’;}
};
class D : public B{
public:
void m() { cout << ‘‘D::m \n’’;}
};
int main(){
D d;
d.m();
}
10
Polymorphism
Name Hiding
When derived class adds a method with the
same name but different signature to the base
class virtual function, this new method hides the
base class virtual function.
Example:
class B {
public:
virtual void m(int x){ cout << ‘‘B::m \n’’;}
};
class D : public B{
public:
void m(){ cout << ‘‘D::m \n’’;} // hides B::m(int)
};
int main(){
D d;
d.m(5); // Error! B::m(int) is hidden.
}
11
Polymorphism
Exercise 3:
Is m() bound at compile time or run time ?
class B {
public:
virtual void m(int x){ cout << ‘‘B::m \n’’;}
};
class D : public B{
public:
virtual void m(){ cout << ‘‘D::m \n’’;}
};
int main(){
B *p;
p = new D;
p -> m();
}
12
Polymorphism
Static Invocation of Virtual Functions
We can override the virtual mechanism when
using the class scope operator to invoke a virtual
function. Thus, the virtual function is resolved
at compile-time.
Example:
class B {
public:
virtual void m(){ cout << ‘‘B::m \n’’;}
};
class D : public B{
public:
void m(){ cout << ‘‘D::m \n’’;}
};
int main(){
B *p = new D;
p -> B::m();
}
13
Polymorphism
Virtual Tables
C++ uses the virtual table (vtable) machanism
to implement the dynamic binding of virtual
functions.
• A class with virtual member functions has a virtual
table which contains the address of its virtual
functions.
• An object of such a class has a pointer(vptr) to
point to the virtual table of the class.
• Dynamic binding is done by looking up the virtual
table for the entry point of the appropriate
function at run-time.
14
Polymorphism
Example:
class B {
public:
virtual void m1(){
// ...
}
virtual void m2(){
// ...
}
};
class D :: B {
void m1(){ // overide B::m1()
// ...
}
};
int main(){
B *p;
B b;
D d;
p = &d; // p is set to d’s address
p -> m1();
p -> m2();
p = &b; // p is set to b’s address
p -> m1()
p -> m2();
}
15
Polymorphism
Constructors and Destructors
• A constructor cannot be virtual since it is used to
construct an object.
• A destructor can be virtual. Virtual destructors
are very useful when some derived classes have
cleanup code.
Example:
class B {
public:
virtual B(); // error
virtual ~B(); // ok
virtual void f(); // ok
};
16
Polymorphism
Example:
class B{
public:
B(){
cout <<"constructing B. \n";
bp = new char[5];
}
~B(){
cout <<"destructing B. \n";
delete[] bp;
}
private:
char *bp;
};
class D : public B{
public:
D(){
cout <<"constructing D. \n";
dp = new char[5000];
}
~D(){
cout <<"destructing D. \n";
delete[] dp;
}
private:
char *dp;
};
int main(){
B *ptr = new D();
delete ptr;
}
OUTPUT?
17
Polymorphism
Fix the problem by using a virtual destructor.
class B{
public:
// ...
virtual ~B(){
cout <<"destructing B. \n";
delete[] bp;
}
// ...
};
class D : public B{
// ...
};
int main(){
B *ptr = new D();
delete ptr;
}
When the destructor of base class is made
virtual, destructors of derived classes are virtual
automatically. Thus, run-time binding is in
effect.
18
Polymorphism
Run-time v.s. compile-time binding
• The approach of using inheritance and run-time
binding facilitates the following software quality
factors:
– Reuse
– Transparent extensibility
– Delaying decisions until run-time
– Architectural simplicity
• Compared to compile time binding, run time
binding has overhead in terms of space and time.
– Extra space is needed for virtual table.
– Extra time for virtual table lookup is required
at each polymorfic function call.
19
Polymorphism
When to choose use different kinds of bindings:
• Use compile-time binding when you are sure that
any derived class will not want to override the
function dynamically.
• Use run-time binding when the derived class may
be able to provide a different implementation that
should be selected at run-time.
20
Polymorphism
Example:
class Shape {
public:
void setDim(double, double = 0);
virtual void showArea();
protected:
double x, y;
};
void Shape::setDim(double xx, double yy) : x(xx), y(yy){}
void Shape::showArea(){
cout << "No area computation defined for this class\n";
}
In base class Shape:
• setDim() is a non-virtual member function since
its operation is common to all derived classes.
• showArea() is declared virtual since the area of
each object is computed differently.
21
Polymorphism
// Derived class Triangle from Shape
class Triangle : public Shape{
public:
virtual void showArea();
};
void Triangle::showArea(){
cout << "Triangle with height " << x << " and base " << y
<< " has an area of " << x * y* 0.5 << endl;
}
// Derived class Rectangle from Shape
class Rectangle : public Shape{
public:
virtual void showArea();
};
void Rectangle::showArea(){
cout << "Rectangle with dimentions " << x << " and " << y
<< " has an area of " << x * y << endl;
}
// Derived class Circle from Shape
class Circle : public Shape{
public:
virtual void showArea();
};
void Circle::showArea(){
cout << "Circle with radius " << x
<< " has an area of " << 3.14 * x * x << endl;
}
22
Polymorphism
int main(){
Shape *ptr; // declare a pointer to base class
Shape myshape; // create objects
Triangle t;
Rectangle s;
Circle c;
ptr = &myshape;
ptr -> showArea();
ptr = &t;
ptr -> setDim(10.0, 5.0);
ptr -> showArea();
ptr = &s;
ptr -> setDim(10.0, 10.0);
ptr -> showArea();
ptr = &c;
ptr -> setDim(10.0);
ptr -> showArea();
}
23
Polymorphism
Pure Virtual Function
• A pure virtual function is a virtual function in base
class that has no definition.
E.g. Consider the virtual function showArea() in
base class Shape; it has only an abstract meaning.
Thus, showArea() can be declared as pure virtual
function.
• A pure virtual function is declared using
specifier “= 0 ”.
24
Polymorphism
Note:
• Only a virtual member function can be pure.
void f() = 0; //error! f() is a stand alone function
class B{
public:
void setX() = 0; //error! setX not virtual
// ...
};
• Declaring a virtual function pure is not the same as
defining a virtual function with an empty body.
class B{
public:
virtual void setX(){} // virtual but not pure
// ...
};
25
Polymorphism
Abstract Classes
• A class that has a pure virtual function is an
abstract class. Abstract class is used as an
interface for its derived classes.
• If a class derived from an abstract class, and this
class doesn’t override all the pure virtual funtion in
the base class, then this class is also an abstract
class.
• No object can be created for an abstract class !
Therefore, classes derived from an abstract class
must override all of the base class’s pure virtual
functions to become “non-abstract”.
26
Polymorphism
Example:
Since class Shape has a pure virtual function, it
becomes an abstract base class (ABC).
Now, class Triangle must override
showArea().
class Shape {
public:
void setDim(double, double = 0);
virtual void showArea() = 0; // pure
protected:
double x, y;
};
class Triangle : public Shape{
// must override Shape::showArea()
// ...
};
27
Polymorphism
Example (Cont’d)
class Shape { // Abstract base class
public:
void setDim(double, double = 0);
virtual void showArea() = 0;
protected:
double x, y;
};
void Shape::setDim(double xx, double yy){
x = xx;
y = yy;
}
class Triangle : public Shape{
public:
virtual void showArea(); // a must !
};
void Triangle::showArea(){
cout << "Triangle with height " << x << " and base " << y
<< " has an area of " << x * y* 0.5 << "\n";
}
class Rectangle : public Shape{
public:
virtual void showArea(); // a must !
};
void Rectangle::showArea(){
cout << "Rectangle with dimentions " << x << " and " << y
<< " has an area of " << x * y << "\n";
}
// ... class Circle
28
Polymorphism
int main(){
Shape *ptr; // pointers to ABC is ok.
Shape myshape; // wrong !
Triangle t;
Rectangle s;
Circle c;
ptr = &t;
ptr -> setDim(10.0, 5.0);
ptr -> showArea();
ptr = &s;
ptr -> setDim(10.0, 10.0);
ptr -> showArea();
ptr = &c;
ptr -> setDim(10.0);
ptr -> showArea();
}
29
Polymorphism
Virtual Multiple Inheritance
class A { ... };
class B : public A { ... };
class C : public A { ... };
class D : public B, public C { ... };
v.s.
class A { ... };
class B : virtual public A { ... };
class C : virtual public A { ... };
class D : public B, public C { ... };
30
Polymorphism
Run-Time Type Checking
C++ supports run-time type
identification(RTTI). It provides mechanisms to
• Check type conversion at run time.
• Determine the actual derived object’s type that a
pointer(or reference) refers to at run time.
Two operators are provided for RTTI support:
• dynamic cast operator
• typeid operator
Used only for polymorphic types, e.g. types with
virtual-functions.
31
Polymorphism
A pointer of derived class can be assigned to a
pointer of base class, which is known as upcast.
A pointer of base class can not be assigned to a
pointer of derived class, which is known as
downcast.
Example:
class B{
public:
int zip() { return x; }
private:
int x;
};
class D : public B{
public:
int zap() { return y; }
private:
int y;
};
int main(){
D *dptr;
B *bptr;
bptr = dptr; // ok, upcast
dptr = bptr; // compile time error
// Cannot assign B* to D* downcast
dptr = static_cast< D* >( bptr ); // ?
}
Downcast might not be safe, but can not be detected by the
compiler.
32
Polymorphism
static cast is not type-safe. Run-time error
may occur.
Example:
int main(){
D *dptr;
B *bptr = new B;
dptr = static_cast< D* >( bptr );
dptr -> zap(); // ?
}
33
Polymorphism
C++ provides dynamic cast for safe type
conversion.
class B{
public:
virtual int zip() { return x; }
private:
int x;
};
class D : public B{
// ...
};
int main(){
D *dptr;
B *bptr = new B;
dptr = dynamic_cast< D* >( bptr );
if (dptr) // check if cast is successful
dptr -> zap();
else
cerr << "Cast not safe \n";
}
dynamic cast is legal only on a polymorphic
type.
dynamic cast performs two operations at once.
First, it verifies that the cast is valid. Then only
if the cast is valid does it perform the cast,
otherwise it returns a null pointer.
34
Polymorphism
dynamic cast provides an alternative to the
virtual function machanism.
#include <iostream>
using namespace std;
class Employee{
public:
virtual void salary() { cout << "Employee::salary"; }
};
class Manager : public Employee{
public:
void salary() { cout << "Manager::salary"; }
};
class Programmer : public Employee{
public:
void salary() { cout << "Programmer::salary"; }
void bonus() { cout << "Programmer::bonus"; }
};
void paycheck( Employee *ep ){
Programmer *pp = dynamic_cast< Programmer* >( ep );
if (pp)
pp -> bonus();
else
ep -> salary();
}
int main(){
Employee *eptr = new Programmer;
paycheck( eptr );
eptr = new Manager;
paycheck( eptr );
}
35
Polymorphism
C++ also provides a typeid operator that
allows queries of type information at run-time.
Example:
#include <iostream>
#include <typeinfo>
using namespace std;
class B_class{
public:
virtual void f(){}
// ...
};
class D_class : public B_class{
// ...
};
int main(){
int x;
cout << typeid( x ).name() << endl;
cout << typeid( 8.16 ).name() <<endl;
D_class dobj;
B_class *bptr = &dobj;
cout << typeid( bptr ).name() << endl;
cout << typeid( *bptr ).name() << endl;
}
36
Polymorphism
The result of the typeid operator can be
compared.
Example:
B_class *bptr = new D_class;
typeid( bptr ) == typeid( B_class* ) // true
typeid( bptr ) == typeid( D_class* ) // false
typeid( bptr ) == typeid( B_class ) // false
typeid( bptr ) == typeid( B_class ) // false
typeid( *bptr ) == typeid( D_class ) // true
typeid( *bptr ) == typeid( B_class ) // false
The typeid operator is used for advanced
system programming.
37
