1

Object Oriented ProgrammingDevelopment - Polymorphism I

By: Marc Conrad & Rob MantonUniversity of Luton

Email: Marc.Conrad@luton.ac.uk Rob.Manton@luton.ac.uk Room: D104

2

Module Outline

IntroductionNon object

oriented basicsClasses

InheritanceAggregationPolymorphismMultifile

Development

3

Today’s lecture

Polymorphism I method overloading operator overloading

4

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.

5

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)

6

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 overridingc) run-time polymorphism

7

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 overridingc) run-time polymorphism

Method overloading can also be applied in non-object oriented contexts and refers both to functions and methods.

8

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 overridingc) run-time polymorphism

Method overriding and run-time

polymorphism are specific to inheritance hierarchies and object oriented programming

(more about this next week..)

9

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 overridingc) run-time polymorphism

Run-time polymorphism, also called dynamic binding, or late binding is often considered as the object oriented feature of C++.

10

Method & Function Overloading

Overloading a function simply means, that a function is not only defined by 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();

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

born1997

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

born1997

These two methods are

different.

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

born1997

These two methods are

different because they have different

argument types.

14

Operator Overloading - Motivation

Question: How many function calls are involved in the following statement?

a = 2 + 3

15

Operator Overloading - Motivation

Question: How many function calls are involved in the following statement?

a = 2 + 3There are two functions implicitly

involved: + and =. Look at this statement as

“assign(a, add(2,3));”

16

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.

17

Overloading Operators - Example

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

A Sandwich filling. may contain bacon

(yes/no).a fraction of a lettuce-leaf.a number of tomato slices.

18

Overloading Operators - Example

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

BLT filling1(true,0.5,2);BLT filling2(false,0.2,0); ...BLT filling3 = filling1 + filling2; .../* Should give a filling with

bacon, 0.7 lettuce and 2 tomatoes*/

19

Overloading Operators - Example

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

BLT filling1(true,0.5,2);BLT filling2(false,0.2,0); …BLT filling3 = filling1 + filling2; ... /* Should give a filling with 3

bacon slices, 0.7 lettuce and 2 tomatoes */

This is the operator we want

to overload

20

Operator Overloading - Example

If we try adding the two objects together at the

moment we get the expected error message

21

Overloading Operators - Example

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

// The C++ SyntaxBLT operator+(BLT x, BLT y) { bool b =x.bacon || y.bacon; float l = x.lettuce + y.lettuce; int t = x.tomatoes =

y.tomatoes; BLT result(b,l,t); return result; }

22

Overloading Operators - Example

+ operator overloaded to accept two BLT objects as

arguments.

23

Overloading Operators - Example

Note: return type is BLT

24

Overloading Operators - Example

Because overloaded + operator returns a

BLT object, this works!

25

Overloading Operators - Example

void operator+=(BLT &x, BLT y) { bool bacon =( x.get_bacon() float lettuce =x.get_lettuce() + int toms=x.get_tomato_slices()+ x.set_bacon(bacon); x.set_lettuce(lettuce); x.set_tomato_slices(toms);}

Where an operator like += actually

needs to change the first operand, we need to use the & (call by reference)

syntax

26

Operator Overloading

Operators can also be overloaded as methods, e.g. the operator +=:

class BLT { // … BLT operator+=(BLT other) { bacon =( bacon || other.bacon); tomatoes += other.tomatoes; lettuce += other.lettuce; } //…

27

Operator Overloading

+= operator overloaded to accept one extra BLT object

as an argument-note void return type

28

Operator Overloading

The const keyword indicates to the

compiler that you are not going to change the other BLT object

in any way

29

Operator Overloading

Operators can also be overloaded as methods, e.g. the operator +=:

class BLT { // … BLT operator+=(BLT other) { bacon =( bacon || other.bacon); tomatoes += other.tomatoes; lettuce += other.lettuce; } //…

BLT filling1(true,0.5,2);BLT filling2(false,0.2,0); … filling1 += filling2; .../* Should give a filling with

bacon, 0.7 lettuce and 2 tomatoes*/

30

Operator Overloading

Operators can also have other types as parameter:

class BLT { // … BLT operator*=(int factor) { tomatoes *= factor; lettuce *= factor; } //…

31

Operator Overloading

Operators can also have other types as parameters:

class BLT { // … BLT operator*=(int factor) { tomatoes *= factor; lettuce *= factor; } //…

BLT filling1(false,0.5,2); … filling1 *= 2; .../* Should give a filling with

no bacon, 1 lettuce and 4 tomatoes

*/

32

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.

33

Operator Overloading - Interesting Observation

cout << “Hello World\n”;

Overloaded << operator

34

Operator Overloading - Interesting Observation

The << operator is overloaded to take a BLT object as an

argument

35

Operator Overloading - Interesting Observation

BLT myFilling(1,0.5,4); cout << myFilling << endl;

Now we can perform class-specific outputusing the standard << syntax!

36

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)