1. 1 COMP313A Programming Languages Object Oriented Progamming Languages (3)

2. 2 Lecture Outline Polymorphism and Strong Typing

3. 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. 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. 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. 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. 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::push csp->push(…); //counting_stack::push sp = csp; //okay sp -> push(…) //which push? dynamic or static binding

8. 8 Type System behavioural equivalence base::f(x) maybe replaced with derived::f(x) without risking any type errors identical signatures

9. 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. 10 Polymorphism – Strong Typing the general case: class base {…}; class derived: public base {…}; … base* b; derived* d; b = d; //allowed d = b; //not allowed The question of substitutability - ensuring is-a Can we substitute d for b always? Is this kind of polymorphism compatible with strong typing?

11. 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. 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. 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. 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. 15 //not C++ input parameters class 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* b derived* d s1 v1; s2 v2; if (..) b = d; b-> fnc(v1); //okay if b is base but what if it is //derived

16. 16 //not C++ result parameter class 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. 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. 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. 19 root child1 child2 grandchild

20. 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. 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. 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. 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. 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. 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; }