Object Oriented Programming Development - Polymorphism

By: Marc Conrad & Rob Manton University of Luton Email: [email protected] [email protected] Room: D104
1

Module Outline
Introduction Non object oriented basics Classes

Inheritance Aggregation Polymorphism Multifile Development

The Meaning of the word.

From the Greek:
Polus + Morphe = Polumorphos

(many )

(shape/form)

The English word "polymorphe" dates from the 19th century and was applied to different animal forms arising in the the same species.

The Meaning of the word.

In object-oriented computing it means: different forms of data being handled by the same type of process. Example: The operator + has a different meaning in the expression 2 + 3 (add two integers) than in 1.7 + 3.3 (add two floating point numbers)

Types of Polymorphism
In Object Oriented Programming there are three types of polymorphism: a) method overloading, with the special and important case of operator overloading b) method overriding c) run-time polymorphism
5

Types of Polymorphism
In Object Oriented Programming there are three types of polymorphism: a) method overloading, with the special and important case of operator overloading Method overloading can b) method overriding also be applied in nonobject oriented contexts c) run-time polymorphism
and refers boths to functions and methods.
6

Types of Polymorphism
In Object Oriented Programming and Method overriding there are three types of polymorphism: run-time polymorphism is specific to the special a) method overloading, with inheritance hierarchies and and important case of operatorobject oriented programming overloading b) method overriding c) run-time polymorphism
7

Types of Polymorphism
In Object Oriented Programming there Run-time polymorphism, are three types of polymorphism: also called dynamic a) method overloading, with the special binding, or late binding is and important case of operator as the often considered overloading object oriented feature of b) method overridingC++. c) run-time polymorphism
8

Method & Function Overloading

Overloading a function simply means, that a function is not only defined its name but by its name and parameter types. The following functions are different in C++:
int makeBreakfast(int i, int k); void makeBreakfast(Creature who); float makeBreakfast();

class Creature { private: int yearOfBirth; public: void setYearOfBirth(int year) { yearOfBirth = year; } void setYearOfBirth(Creature other) { yearOfBirth = other.yearOfBirth; } int getYearOfBirth() { return yearOfBirth; } };

Example: The Creature class

born1997

class Creature { private: These two methods int yearOfBirth; are different. public: void setYearOfBirth(int year) { yearOfBirth = year; } void setYearOfBirth(Creature other) { yearOfBirth = other.yearOfBirth; } int getYearOfBirth() { return yearOfBirth; born1997 } };

Example: The Creature class

Example: The Creature class These two methods class Creature {

are different private: because they have int yearOfBirth; different argument public: void setYearOfBirth(int year) { types. yearOfBirth = year; } void setYearOfBirth(Creature other) { yearOfBirth = other.yearOfBirth; } int getYearOfBirth() { return yearOfBirth; born1997 } };

Operator Overloading Motivation

Question: How many function calls are involved in the following statement? a=2+3

13

Operator Overloading Motivation

Question: How many function calls are involved in the following statement? a=2+3 There are two functions implicitly involved: + and =. Look at this statement as assign(a, add(2,3));
14

Operator Overloading
So, operators as +, -, *, <<, =, etc. can be seen as functions as well. That means we can overload operators. The C++ syntax uses function names prefixed with operator for overloading operators.

15

Overloading Operators Example

class BLT { public: bool bacon; float lettuce; int tomatoes; // Constructor: BLT(bool b, float // (more code) };

A Sandwich filling. may contain bacon (yes/no). a fraction of a lettuce-leaf. a number of tomato slices.
l, int t);

16

Overloading Operators Example BLT filling1(true,0.5,2);

BLT filling2(false,0.2,0); class BLT { ... public: BLT filling3 = filling1 + filling2; bool bacon; ... float lettuce; /* Should give a filling with int tomatoes; bacon, 0.7 lettuce and 2 // Constructor: tomatoes*/ BLT(bool b, float l, int t); // (more code) };
17

Overloading Operators Example BLT filling1(true,0.5,2);

BLT filling2(false,0.2,0); class BLT { public: BLT filling3 = filling1 + filling2; bool bacon; ... float lettuce; /* Should give a filling with 3 int tomatoes; bacon slices, 0.7 lettuce and // Constructor: 2 tomatoes */ BLT(bool b, float l, int t); This is the operator // (more code) we want to overload };
18

Overloading Operators Example // The C++ Syntax

BLT operator+(BLT y, BLT z) { class BLT { bool b = y.bacon || z.bacon; public: float l = y.lettuce + z.lettuce; bool bacon; int t = y.tomatoes = z.tomatoes; float lettuce; BLT result(b,l,t); int tomatoes; return result; // Constructor: } BLT(bool b, float l, int t); // (more code) };
19

Operator Overloading
Operators can also be overloaded as methods, e.g. the operator +=:
class BLT { // BLT operator+=(BLT other) { bacon ||= other.bacon; tomatoes += other.tomatoes; lettuce += other.lettuce; } //
20

BLT filling1(true,0.5,2); BLT filling2(false,0.2,0); Operator Overloading filling1 += filling2; Operators can also be overloaded as ... methods, e.g. the operator +=: /* Should give a filling with class BLT { bacon, 0.7 lettuce and 2 // tomatoes*/ BLT operator+=(BLT other) {
// bacon ||= other.bacon; tomatoes += other.tomatoes; lettuce += other.lettuce; }

21

Operator Overloading
Operators can also have other types as parameter:
class BLT { // BLT operator*=(int factor) { tomatoes *= 2; lettuce *= 2; } //
22

BLT filling1(false,0.5,2); Operator Overloading filling1 *= 2; ... Operators can alsoShould other types with no /* have give a filling as parameters: bacon, 1 lettuce and 4 class BLT { tomatoes // */
BLT operator*=(int factor) { tomatoes *= factor; lettuce *= factor; } //

23

Operator Overloading
The following operators can be overloaded:
new, delete, +, -, *, /, %, ^, &, |, ~, !, =, <, >, +=, -=, *=, /=, %=, ^=, &=, |=, <<, >>, >>=, <<=, ==, !=, <=, >=, &&, ||, ++, --, , , ->*. ->, (), [] Note that "=" has already a default behaviour. When "overloaded" it will be in fact overridden.
24

Operator Overloading Interesting Observation

cout << Hello World\n;

Overloaded << operator

25

Operator Overloading Summary

Operators may be overloaded to work with user defined data types (objects). The syntax for overloading involves the 'operator' keyword and the operator.
Note: In a good design it is important, that the normal meanings of operators are not distorted (don't subtract with a + operator)

26

Polymorphic Pointers
In C++ a pointer of a parent class is allowed to point to an object of the child class. E.g.
class Vehicle { // ... }; class Car : public Vehicle { // ... }; // ... Vehicle vp = new Car();

27

Overriding Methods
Methods in the parent class can be redifined in the child class.
class Vehicle { void move(int i); }; class Car : public Vehicle { void move(int i); }; // ... Vehicle vp = new Car(); vp->move(100);

28

Overriding Methods
Methods in the parent class can be redifined in the child class. BUT: class Vehicle { void move(int i); Which of these }; two move() class Car : public Vehicle { void move(int i); methods will be }; called?
// ... Vehicle vp = new Car(); vp->move(100);

29

Overriding Methods
Methods in the parent class can be redifined in the child class.
class Vehicle { void move(int i); }; class Car : public Vehicle { void move(int i); }; // ... Vehicle vp = new Car(); vp->move(100);

static typing

30

Overriding Methods
Methods in the parent class can be redifined in the child class.
class Vehicle { void move(int i); }; class Car : public Vehicle { void move(int i); }; // ... Vehicle vp = new Car(); vp->move(100);

dynamic binding?

31

Overriding Methods
Methods in the parent class can be redifined in the child class. static typing! class Vehicle {
void move(int i); }; class Car : public Vehicle { void move(int i); }; // ... Vehicle vp = new Car(); vp->move(100);

In C++, static typing is the default behaviour.

As vp is of type pointer to a Vehicle, the method of the Vehicle is called. 32

Overriding Methods The keyword virtual

Methods in the parent class can be redifined in the child class. dynamic binding! class Vehicle {
virtual void move(int i); }; class Car : public Vehicle { virtual void move(int i); }; // ... Vehicle vp = new Car(); vp->move(100);

The keyword virtual allows the use of dynamic binding.

As vp points to a Car object the method of the Car is called

33

Abstract Methods & Classes

Abstract methods are methods without any implementation (pure virtual methods).
class Vehicle { virtual void move(int i) = 0; }; class Car : public Vehicle { virtual void move(int i); }; // ... Vehicle vp = new Car(); vp->move(100);

Syntax for declaring abstract methods.

Note that Vehicle objects cannot be instantiated (but Car objects).

34

Static typing & Dynamic binding

Static typing means that the legality of a member function invocation is checked at the earliest possible moment: by the compiler at compile time. The compiler uses the static type of the pointer to determine whether the member function invocation is legal.
Dynamic binding means that the address of the code in a member function invocation is determined at the last possible moment: based on the dynamic type of the object at run time. It is called "dynamic binding" because the binding to the code that actually gets called is accomplished dynamically (at run time).
35

Important stuff to remember

Overriding methods Polymorphic pointers Static binding Dynamic binding - the virtual keyword Abstract methods

36