2CPP10 - Polymorphism

Introduction
• The last of the three fundamental pillars of object
orientation is the principle of polymorphism.
• It’s also the most abstract and difficult to initially see the benefits of.
• In the C++ model of polymorphism, it is inextricably tied
up in the idea of inheritance.
• They go together, hand in hand.

Polymorphism
• The word Polymorphism comes from the Greek.
• Poly meaning ‘parrot’
• Morph meaning ‘small man made of plasticine’.
• In basic terms, it means:
• To treat a specialised object as an instance of its more general
case.
• For example, a Circle is a Circle.
• But in a more general way, it’s also a shape.

The Scenario
• We’re going to explore the topic of polymorphism through
a simple example program.
• It relates to the relationship between two classes – an Employee
and a Manager.
• They are very similar except:
• Managers can hire and fire
• Employees cannot.

The Employee Class
class Employee {
private:
int payscale;
public:
int query_payscale();
void set_payscale (int p);
bool can_hire_and_fire();
};
#include "Employee.h"
bool Employee::can_hire_and_fire(){
return false;
}
void Employee::set_payscale(int val) {
payscale = val;
}
int Employee::query_payscale() {
return payscale;
}

The Manager Class
class Manager : public Employee {
public:
};
#include "Manager.h"
bool Manager::can_hire_and_fire() {
return true;
}

The Program
#include <iostream>
using namespace std;
int main(int argc, char** argv) {
Employee *emp = new Employee();
Manager *man = new Manager();
cout << "Employees hiring and firing rights:" << emp-
>can_hire_and_fire() << endl;
cout << "Managerss hiring and firing rights:" << man-
return 1
}

The Output
• So far, it’s pretty straightforward.
• Output for employees is 0.
• False
• Output for managers is 1.
• True.
• So it is written, so shall it be.
• The polymorphism comes in when when we want to do something
a little more arcane.
• Make a pointer to a base class point to am object of a more specialised
class.

Polymorphism
#include <iostream>
Employee *poly = new Manager();
cout << "Employees hiring and firing rights:" << emp->can_hire_and_fire() <<
endl;
cout << "Managers hiring and firing rights:" << man->can_hire_and_fire() <<
endl;
cout << "Polymorphic hiring and firing rights:" << poly-
return 1;
}

And…?
• What happens now?
• In Java, it calls the most specialised version of the method.
• It would call the one defined in Manager.
• In C++, it calls the method as defined in the class that is referenced
by the pointer.
• It would call the one defined in Employee.
• Okay, great – but so what?

The Power
• The power comes from when we have many different
classes that extend from a common core.
• Rather than coding special conditions for each of them, we code for
the base class.
• This greatly reduces the amount of work that a developer
has to do.
• And properly distributes the responsibility for implementing
functionality.

Virtual Functions
• However, much of this is based on the idea that we can
trust a generalised reference to execute the most
appropriate method.
• As is done in Java
• C++ requires us to define a function as virtual if we want
this behaviour.
• From this point on, it becomes a virtual function and behaves in
the way we would expect from Java.

Modified Class Definition
class Employee {
private:
int payscale;
public:
int query_payscale();
void set_payscale (int p);
virtual bool can_hire_and_fire();
};

How Do Virtuals Work?
• When an object is created from a class, C++ creates a lookup
table for virtual functions.
• This is in addition to all other data stored.
• Each virtual function has an entry in this table.
• When you create the object with new, the entry is updated with a
reference to the appropriately specialized implementation.
• Each virtual method you declare increases the size of this
table.
• And thus size of the objects and processing time.

Clerical Staff
class Clerical: public Employee {
public:
void file_papers();
};
#include "Clerical.h"
bool Clerical::can_hire_and_fire() {
return false;
}
void Clerical::file_papers() {
// Something Something
}

Modified Scenario
• Two classes stem from the same root.
• Employee
• Using the Power of Polymorphism, we can treat them as
instances of the base class.
• We can manipulate them as if they were just Employees.
• This means that we can’t make use of methods defined in the
specialised classes.
• Only what we can guarantee is implemented by virtue of the class
hierarchy.

New Code
void set_payscale (Employee* emp, float amount) {
emp->set_payscale (amount);
}
Clerical *cler = new Clerical();
cout << "Employees hiring and firing rights:" << emp->can_hire_and_fire() << endl;
cout << "Managers hiring and firing rights:" << man->can_hire_and_fire() << endl;
cout << "Clerical hiring and firing rights:" << cler->can_hire_and_fire() << endl;
set_payscale (cler, 15000.0);
set_payscale (man, 25000.0);
cout << "Clerical payscale: " << cler->query_payscale() << endl;
cout << "Manager payscale: " << man->query_payscale() << endl;
return 1;
}

The Employee Class
• The Employee class is now something we don’t really
want people using it.
• It’s a common core, not a fully fledged object in its own right.
• In the next lecture, we’ll look at how we can prevent
people making use of it directly.
• We’ll also look at ways other than inheritance to provide a structure
for objects.

Benefits of Polymorphism
• One of the benefits that comes from polymorphism is the
ease of processing lists of objects.
• We don’t need a separate queue for Managers and Clerical staff
• We just need one queue of employees
• We can iterate over each of these, provided we are
making use of base functions.

void set_payscale (Employee* emp, float amount) {
emp->set_payscale (amount);
}
Employee **emps = new Employee*[2];
emps[0] = new Manager();
emps[1] = new Clerical();
for (int i = 0; i < 2; i++) {
set_payscale (emps[i], 20000.0);
cout << "Payscale for " << i << " is " << emps[i]->query_payscale() << endl;
}
return 1;
}

• Polymorphism manages the complexity of the inheritance
model and lets you provide custom handling in the classes
themselves.
• You don’t need:
• if (it’s a manager) { do_this(); } else if (it’s a clerical) {
do_this_other_thing() }
• One method, properly designed, can handle all the heavy
lifting.
• This does require the use of a clean, well designed object hierarchy.

Summary
• Polymorphism is the last of the three pillars of object
oriented programming.
• The most powerful, but also the most abstract.
• You’re not really expected to ‘get it’ just yet.
• We’ll return to the topic in later lectures.
• In the next lecture we’re going to continue discussing
some of the ways in which we can enforce structure on
our unruly objects.

2CPP10 - Polymorphism

More Related Content

What's hot (19)

Viewers also liked (8)

Similar to 2CPP10 - Polymorphism (20)

More from Michael Heron (20)

Recently uploaded (20)

2CPP10 - Polymorphism