1

COMP313A Programming Languages

Object Oriented Progamming Languages (3)

2

Lecture Outline

• Polymorphism and Strong Typing

3

Polymorphism• polymorphic variables could refer to objects of

different classes– what is the problem for a type checker

• How do we allow dynamic binding and still ensure type safety

• strong type system limits polymorphism– restricted to objects of a class or its derived classes– e.g. variables of type stack may refer to a variable of

type counting_stack• Strict object-oriented languages (Smalltalk,

Eiffel, Java– all objects accessed through references which may

be polymorphic• C++ - pointers, reference variables and by-

reference parameters are polymorphic

4

If we do not use pointers we do not get inclusion polymorphism. But…

stack s;counting_stack cs;

s = cs; //okay coerce cs to a stack

cs = s; //not okay

5

The Type System

• The subtype principle

• a week day is also a day – is-a relationship

• similarly class and sub-class– counting_stack is-a stack

• but….

type day = (Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday); weekday = (Monday..Friday);

6

The Type System

• need to state the conditions under which the isa relationship holds for subclasses of classes because…

• subclasses can hide the variables and functions or modify them in an incompatible way

• need to know when they are equivalent with the parent’s definition

7

Dynamic Binding of Calls to Member Functions

• a derived class can override a member function of the parent class

stack* sp = new stack;counting_stack* csp = new counting_stack;

sp->push(…); //stack::pushcsp->push(…); //counting_stack::push

sp = csp; //okay

sp -> push(…) //which push?

dynamic or static binding

8

Type System

• behavioural equivalence

• base::f(x) maybe replaced with derived::f(x) without risking any type errors

• identical signatures

9

Polymorphism – Strong Typing

• Strong typing means that

How can we have dynamic binding and a strong type system

stack* sp = new stack;counting_stack* csp = new counting_stack;

sp = csp; //allowed

csp = sp; //not allowed

10

Polymorphism – Strong Typing

the general case:

class base {…};class derived: public base {…};

…

base* b;derived* d;

b = d; //allowedd = b; //not allowed

The question of substitutability - ensuring is-aCan we substitute d for b always?Is this kind of polymorphism compatible with strong typing?

11

• Substitutability– impose some restrictions on the use of

inheritance

1. Type extension– the derived class can only extend the type of base

class– can’t modify or hide any member variables or

functions– Ada 95– problem is it rules out dynamic binding (dynamic

dispatch) completely

Polymorphism – Strong Typing

12

2. Overriding of member functions

Polymorphism – Strong Typing

class polygon{ public: polygon (..){…} //constructor virtual float perimeter () {…};};class square : public polygon { public: square (..) {…} //constructor … float perimeter() {…}; //overrides the definition of //perimeter in polygon

13

• under what conditions is it possible for a use of a square object to substitute the use of a polygon object,

i.e. p-> perimeter() will be valid whether *p is a polygon or a square object

C++ the signature of the overriding function must be identical to that of the overridden function

- exactly the same parameter requirements no type violations

What happens at runtime?

Polymorphism – Strong Typing

14

• Is it possible to relax this last restriction even further but still ensuring type safety?

• The input parameters of the overriding function must be supertypes of the corresponding parameters of the overriden function contravariance rule

• The result parameter of the overriding function must be a subtype of the result parameter of the overriden function covariance rule

Polymorphism – Strong Typing

15

//not C++ input parametersclass base { public: void virtual fnc (s1 par) {..} // S1 is the type of the formal // parameter}

class derived: public base { public: void fnc (s2 par) {…} // C++ requires that s1 is

identical to // S2

}

base* bderived* ds1 v1;s2 v2;

if (..) b = d;

b-> fnc(v1); //okay if b is base but what if it is //derived

16

//not C++ result parameterclass base { public: t1 virtual fnc (s1 par) {…}; // s1 is the type of formal parameter // t1 is the type of result parameter};class derived: public base { public: t2 fnc (s2 par) {…}; // C++ requires that s1 is identical to // s2 and t1 is identical to t2};

base* b;derived* d;s1 v1;s2 v2;t1 v0;

if (…) b = d;v0 = b->fnc(v1); // okay if b is base but what if it is derived

17

• Who uses it?

• Emerald uses both contravariance and covariance

• C++, Java, Object Pascal and Modula-3 use neither – use exact identity

• Eiffel and Ada require covariance of both input and result parameters

Polymorphism – Strong Typing

18

Issues in Inheritance Hierarchies

• Ada, Java and Smalltalk have a single inheritance model

• Java has separate interfaces and supports the idea of inheriting from multiple interfaces

• C++ and Eiffel have multiple inheritance

• What if both elephant and circus_performer have a member function ‘trunk_wag’

• Diamond inheritance

class circus_elephant: public elephant, circus_performer

19

root

child1 child2

grandchild

20

Implementation and interface inheritance

• object oriented programming new software components may be constructed from existing software components

• inheritance complicates the issue of encapsulation

• interface inheritance derived class can only access the parent class through the public interface

• implementation inheritance derived class can access the private internal representation of the parent class

21

Protected Members

class stack{ public: void push(int, i){elements[top++] = I;}; int pop () {return elements[--top];}; private: int elements[100]; int top =0;};

class counting_stack: public stack { public: int size(); //return number of elements on stack

stack s1, s2;

stack* sp = new stack;

sp->pop()

22

Protected Members• implementation inheritance versus interface

inheritance

• protected entities are visible within the class and any derived classes

class stack{ public: void push(int, i){elements[top++] = I;}; int pop () {return elements[--top];}; protected int top = 0; private: int elements[100];};class counting_stack: public stack { public: int size(){return top;}; //return number of elements on stack

23

Protected Members

class C { public: // accessible to everyone protected: // accessible to members and friends and // to members and friends of derived classes only private: //accessible to members and friends only};

24

Friends

class Matrix;

class Vector { float v[4];

friend Vector operator* (const Matrix&, const Vector&); };

class Matrix { Vector v[4];

friend Vector operator* (const Matrix&, const Vector&);}

25

Vector operator* (const Matrix& m, const Vector& v){ Vector r; for (int i = 0; i < 4; i++) { r.v[i] = 0; for (int j = 0; j ,4; j++) r.v[i] += m.v[i].v[j] * v.v[j]; } return r;}