Run-time Polymorphism
1
Review — Accessing Members of
Base and Derived Classes
class B { The following are legal:–
public: B_obj.m() //B’s m()
void m(); B_obj.n()
void n();
... D_obj.m() //D’s m()
} // class B D_obj.n() //B’s n()
D_obj.p()
class D: public B {
public B_ptr->m() //B’s m()
void m(); B_ptr->n()
void p();
... D_ptr->m() //D’s m()
D_ptr->n() //B’s n()
} // class D
D_ptr->p()
2 Polymorphism
Review — Accessing Members of
Base and Derived Classes (continued)
class B { The following are legal:–
public: B_ptr = D_ptr;
void m();
void n(); The following are not legal:–
... D_ptr = B_ptr;
} // class B B_ptr->p();
Even if B_ptr is known to point to an
object of class D
class D: public B {
public
void m(); Class D redefines method m()
void p();
...
} // class D
3 Polymorphism
Review — Accessing Members of
Base and Derived Classes (continued)
Access to members of a class object is determined by the
type of the handle.
Definition: Handle
The thing by which the members of an object are accessed
Deitel & Deitel, §20.3
May be
An object name (i.e., variable, etc.)
A reference to an object
Note: this is not exactly the same
A pointer to an object
thing as handle classes mentioned
by Stroustrup
4 Polymorphism
Review — Accessing Members of
Base and Derived Classes (continued)
This is referred to as static binding
I.e., the binding between handles and members is determined
at compile time
I.e., statically
5 Polymorphism
What if we need Dynamic Binding?
I.e., what if we need a class in class Rectangle: public
which access to methods is Shape {
determined at run time by public:
the type of the object, not the void Rotate();
type of the handle void Draw();
...
class Shape { }
public:
void Rotate(); class Ellipse: public
void Draw(); Shape {
... public:
} void Rotate();
void Draw();
...
}
6 Polymorphism
Solution – Virtual Functions
Define a method as virtual, and the subclass method overrides
the base class method
E.g.,
class Shape {
public: This tells the compiler to add
virtual void Rotate(); internal pointers to every object
of class Shape and its derived
virtual void Draw();
classes, so that pointers to
... correct methods can be stored
} with each object.
7 Polymorphism
What if we need Dynamic Binding?
class Shape { class Rectangle: public Shape
public: {
virtual void Rotate(); public:
virtual void Draw(); void Rotate();
... void Draw();
} ...
}
I.e., subclass methods override the
base class methods class Ellipse: public Shape {
(if specified)
public:
C++ dynamically chooses the void Rotate();
correct method for the class from void Draw();
which the object was instantiated. ...
}
8 Polymorphism
Notes on virtual
If a method is declared virtual in a class,
… it is automatically virtual in all derived classes
It is a really, really good idea to make destructors virtual!
virtual ~Shape();
Reason: to invoke the correct destructor, no matter how object
is accessed
9 Polymorphism
Notes on virtual (continued)
A derived class may optionally override a virtual function
If not, base class method is used
class Shape {
public:
virtual void Rotate();
virtual void Draw();
...
}
class Line: public Shape {
public:
void Rotate();
//Use base class Draw method
...
}
10 Polymorphism
Example
Deitel & Deitel, §24.3
CommissionEmployee and
BasePlusCommissionEmployee
11 Polymorphism
Polymorphism
The ability to declare functions/methods as virtual is
one of the central elements of polymorphism in C++
Polymorphism:– from the Greek “having multiple forms”
In programming languages, the ability to assign a different meaning or
usage to something in different contexts
12 Polymorphism
A Note from D&D on virtual
When a virtual function is called by name of a specific
object
using the dot member-selection operator (e.g.,
squareObject.draw() ),
… the function invocation is resolved at compile time
This is static binding, not polymorphic behavior!
Dynamic binding with virtual functions only occurs from
pointer and reference handles
Have not been able to verify
13 Polymorphism from any other source!
Summary – Based and Derived Class
Pointers
Base-class pointer pointing to base-class object
Straightforward
Derived-class pointer pointing to derived-class object
Straightforward
Base-class pointer pointing to derived-class object
Safe
Can access non-virtual methods of only base-class
Can access virtual methods of derived class
Derived-class pointer pointing to base-class object
Compilation error
14 Polymorphism
Abstract and Concrete Classes
Abstract Classes
Classes from which it is never intended to instantiate any objects
Incomplete—derived classes must define the “missing pieces”.
Too generic to define real objects.
Definitions
Normally used as base classes and called abstract base classes
Provide appropriate base class frameworks from which other classes can inherit.
Concrete Classes
Classes used to instantiate objects
Must provide implementation for every member function they define
15 Polymorphism
Pure virtual Functions
A class is made abstract by declaring one or more of its virtual
functions to be “pure”
I.e., by placing "= 0" in its declaration
Example
virtual void draw() const = 0;
"= 0" is known as a pure specifier.
Tells compiler that there is no implementation.
16 Polymorphism
Pure virtual Functions (continued)
Every concrete derived class must override all base-class pure
virtual functions
with concrete implementations
If even one pure virtual function is not overridden, the
derived-class will also be abstract
Compiler will refuse to create any objects of the class
Cannot call a constructor
17 Polymorphism
Purpose
When it does not make sense for base class to have an
implementation of a function
Software design requires all concrete derived classes to
implement the function
Themselves
18 Polymorphism
Why Do we Want to do This?
To define a common public interface for the various classes in a
class hierarchy
Create framework for abstractions defined in our software
system
The heart of object-oriented programming
Simplifies a lot of big software systems
Enables code re-use in a major way
Readable, maintainable, adaptable code
19 Polymorphism
Abstract Classes and Pure virtual
Functions
Abstract base class can be used to declare pointers and
references referring to objects of any derived concrete
class
Pointers and references used to manipulate derived-
class objects polymorphically
Polymorphism is particularly effective for
implementing layered software systems – e.g.,
1. Reading or writing data from and to devices.
2. Iterator classes to traverse all the objects in a container.
20 Polymorphism
Example – Graphical User Interfaces
All objects on the screen are represented by derived
classes from an abstract base class
Common windowing functions
Redraw or refresh
Highlight
Respond to mouse entry, mouse clicks, user actions, etc.
Every object has its own implementation of these
functions
Invoked polymorphically by windowing system
21 Polymorphism
