Object Oriented Programming

1. Object Oriented Programming

2. What’s the Object? • Global name space for functions in C • Every function is available everywhere • No structural association between functions and data • No hiding of private functions or data • Code re-use is difficult

3. Object Oriented Programming in C++ • Classes as units of encapsulation • Information Hiding • Inheritance • Polymorphism and dynamic dispatching • Storage management

4. Classes • Encapsulation of type and related operations class point { double x,y; // private data members public: point (int x0, int y0); // public methods point () { x = 0; y = 0;}; // a constructor void move (int dx, int dy); void rotate (double alpha); int distance (point p); }

5. A Class is a type : Objects are instances • Create a global or local variable point p1(10, 20); // Calls constructor point(int x0, int y0) point p2; // Calls default constructor (no arguments) • Create an object on the heap point p3 = new point; • point is a type • p1, p2, p3 are instances of the type • p1, p2, p3 are objects • Definitions of Object: • C++ An object is a region of storage • Java An object is a class instance or array

6. Implementing methods • Class definition is similar to ADA package spec, and usually appears in a header file • No equivalent of ADA package body: each method can be defined separately void point::rotate (double alpha) { x = x * cos (alpha) - y * sin (alpha); y = y * cos (alpha) + x * cos (alpha); }; x and y are data members of the object on which the method is being called. • Methods can be inlined • Must be defined in the class declaration • “inline” keyword is a suggestion for the compiler

7. Constructors • One of the best innovations of C++ • Special method (s) invoked automatically when an object of the class is declared point (int x1, int x2); point (); point (double alpha; double r); point p1 (10,10), p2; p3 (pi / 4, 2.5); • Allows initialization of instance • Setting default values • Initializing data structures • Name of method is name of class • Declaration has no return type.

8. Class Methods • Member functions are called with a special syntax p1.move(3, -12); // p1 is an instance of class point • Method Name Mangling point_move$i$i_v(point* this, int x0, int y0) • Name includes class name and types of arguments • Resolves identically named methods in different classes • Allows overloading of names within a class • Allows linking with programs written in C and other languages • And the instance is passed as a hidden argument point_move$i$i_v(p1, 3, -12)

9. Target of operation • The implicit parameter in a method call can be retrieved through this: class Collection { Collection& insert (thing x) { // return reference … modify data structure return *this; // to modified object }; }; my_collection.insert (x1).insert (x2); • Common Java Idiom • point (int x0, y0) { • this.x0 = x0; • this.y0 = y0;}

10. Static Members • Need to have computable attributes for class itself, independent of specific object; e.g. number of objects created. • Static qualifier indicates that entity is unique for the class – There is only one, shared by all class instances. staticint num_objects = 0; point () { num_objects++;}; // ditto for other constructors • Can access static data using class name or object name: if (point.num_objects != p1.num_objects) error ();

11. Classes and Private Types • If all data members are private, class is identical to a private type: visible methods, including assignment. • A struct is a class with all public members • How much to reveal is up to programmer • What about private constructors? • define functions to retrieve (not modify) private data int xcoord () { return x;}; int ycoord () { return y;}; p2.x = 15; // error, data member x is private

12. Destructors • If constructor allocates dynamic storage, need to reclaim it class stack { int* contents; int sz; public: stack (int size) { contents = newint [ sz = size];}; void push (); int pop (); int size () { return sz;}; } stack my_stack (100); // allocate storage dynamically // when is my_stack.contents released?

13. Destructors (cont.) • User cannot deallocate data if data member is private: system must do it stack ( ) {contents = new ContentType[n];}; ~stack ( ) {delete[ ] contents;}; • inventive syntax: negation of constructor • Symmetry of ctor & dtor makes program easier to understand • Called: • automatically when object goes out of scope • indirectly by delete • Almost never called explicitly • Many uses: • Linked list maintenance • Files: open in constructor, close in destructor

14. Copy and Assignment point p3 (10,20); point p5 = p3; // componentwise copy • This can lead to unwanted sharing: stack stack1 (200); stack stack2 = stack1; // stack1.contents shared stack2.push (15); // stack1 is modified • Need to redefine assignment and copy

15. Copy Constructors stack (const stack& s) { // reference to existing object contents = new int [ sz = s.size()]; for (int I = 0; I <sz; I++) contents [I] = s.contents [I]; } stack s1 (100); … stack s2 = s1; // invokes copy constructor

16. Redefining Assignment • assignment can also be redefined to avoid unwanted sharing • operator returns a reference, so it can be used efficiently in chained assignments: one = two = three; stack & operator= (const stack& s) { if (this != &s) { // beware of self-assignment delete [] contents; // discard old value contents = newint [sz = s.size ()]; for (int I = 0; I <sz; I++) contents [I] = s.contents [I]; } return *this; } stack s1 (100), s2 (200); … s1 = s2; // transfer contents

17. Operator Overloading: indexing • Useful to create range-checked structures: class four_vect { double stor[4]; // private member, actual contents of vector. … double&operator[ ] (int j) { if (j < 0 || I > 3) throw index_error; // defined elsewhere return stor[j]; }; Note: return type is a reference, so can be used on l.h.s

18. Extending the meaning of subscripting • An associative array: class Assoc { // a map from strings to numbers struct Pair { // an inner class char* name; double val; Pair (char* n = “”, double v = 0): name (n), val (v) { }; }; pair * contents; // Assoc is a set of pairs public: Assoc () { }; // default constructor double& operator[ ] (const char*); // map string => number };

19. Efficiency vs. privacy • Linear algebra package: vector class for 4-vectors, matrix class for 4-by-4 matrices • vector class redefines [ ] to do check index • matrix class redefines [ ] to check both indices • want to implement matrix * vector: • v1 [j] = S m[j][k] * v [k]; • 4 range-checks for every component, all redundant.

20. Relaxing privacy: friends • A friend function can access private members of a class • a friend is declared in the class (cannot sneak in) class vector {... friend vector operator* (const matrix&, const vector&); • a function can be the friend of several classes class matrix {… friend vector operator*(const matrix&, const vector&); • A class can be a friend, so all its function members are. class quaternion { friendclass matrix; …} • A friend in not a class member

21. Efficient code class matrix { vector row [4]; public: … }; vector operator * (const matrix&m, const vector v) { vector res; for (int i = 0; i < 4; i ++) { res.stor[i] = 0; // stor is private data in a vector for (int j = 0; j < 4; j++) res.stor[j] += m.row[i].stor[j] * v.stor[j]; // row is private }; return res; };

22. Packages and private information • In Ada, declare both types in same package. Package body has access to full declarations for both: package linear_algebra is type vector is private; type matrix is private; function “*” (m : matrix; v : vector) return vector; private type vector is array (1..4) of long_float; type matrix is array (1..4) of vector; -- code in body can use array representation of both. endlinear_algebra;

23. Inheritance • General mechanism for extending existing classes. • Specialization: an X is an A • A mammal is a vertebrate • a feline is a mammal • a cat is a feline • a persian is a cat • A persian has all the attributes of a feline, a mammal, and a vertebrate • A class hierarchy implements a sequence of Is-A relations

24. Advantages of inheritance • Factorization: Common properties are grouped in a single class • code reuse : Descendant class (derived class) is defined incrementally over parent. • incrementalprogramming : New derived classes can be added without changing existing parents and siblings. • Is inheritance Polymorphism? • Can describe collections of diverse objects belonging to a class hierarchy. • Just saves copying common factors in related classes

25. Derivation class point { // base class int x, y; public: point () { x = 0; y = 0}; // basic constructor void move (int dx, int dy) { x += dx; y += dy}; } void display ( ) ; // put black dot on the screen. } class color_point: public point { // derived class int R, G, B; // in addition to hidden members x, y public: color_point ():point () {R = 50; G = 50; B = 50;}; // call parent constr. void lighten (int w) { R -= w; G -=w; B -= w;}; void display ( ); // put colored dot on the screen // move is inherited, applies to color_points as well };

26. Substitution rule • An object from a derived class can be used wherever an object from the base class is expected. point* p1 = new color_point ( ); • works because a descendant has all the attributes of the parent (possibly with different meanings). color_point* wrong = new point ( ); // error: incomplete object • but p1 can be coerced (cast) to a color_point, because it is one.

27. inheritance and privacy • Private members of the parent class are not visible in (the methods of) the derived class. int color_point::abcisa ( ) {return x; }; // error • Constructor for parent is used to initialize parent data. Derived (…) : Parent (…) { …}; // rest of construction • Protected members are visible in descendants, but not outside.

28. Polymorphism • Because of substitution rule, can have collection of various kinds of points: point* figure [100]; • To display collection, apply the appropriate display method to each: point::display () color_point::display () blinkling_point::display () • Could add discriminant to each object, to recognize its class • But don’t do it! • Best to use virtual methods.

29. Virtual methods class parent { virtual void change (int x) … class child: public parent { virtual void change (int x) … // overrides parent operation class grandchild: public child { virtual void change (int x)… // overrides child operation parent* someone = … // can be any member of family someone-> change () // the proper one for someone’s class

30. Dynamic dispatching • If M is virtual, the call ptr -> m (..) must determine the actual nature of ptr, and invoke the proper method • Each class is described by a table of virtual methods (the vtable) • Each object carries a pointer to the vtable. • Each derived class inherits the table • each overriding modifies an entry in the table • Dynamic dispatching is an indirect call through an entry at a known position in the vtable.

31. Overloading and dynamic dispatching • Overloading resolution is a compile-time process that applies to an expression in a context: that = this_one + the_other; // find right numeric type • dynamic dispatching is a run-time activity that applies to a reference: some_relative-> display (); // indirect call tommy.display (); // static resolution • overloading resolution may fail if call is ambiguous • dynamic dispatching succeeds because derived classes have all the virtual methods of ancestors.

32. The profile of an overriding method class parent { virtual void method (int x); virtual void relation (parent x); class child: public parent { virtual void method (int x); // overrides inherited method virtual void method (double x); // different method Binary operations are not symmetric: virtual void relation (child x); // does not override parent relation virtual void relation (parent x); // overrides

33. Abstract classes • Base class may not have enough attributes to create meaningful object: class shape { point anchor; int color [3]; virtual void display (); // can’t write anything here }; shape blob; // can’t do anything with it • If methods are declared abstract, cannot create objects of class: virtual void display ( ) = 0; // must be overridden

34. A useful pattern: the factory • Need to construct different objects based on run-time values • Construct objects based on user input • Handle messages of different types class MessageFactory { Message messageHandler(byte[] data) { switch (data[0]) { case 1: return new BuyMessage(data); case 2: return new SellMessage(data); case 3: return new CloseMessage(data); . . . } };

35. Multiple inheritance • Class can inherit from several parents: class abstract_stack { // algebraic definition public: void push (int x) = 0; ... }; class vector {…}; // sequential allocation class stack: public abstract_stack, public vector { public: void push (int x) { .. }; // use vector primitives } • Mix-in Inheritance

36. Multi-methods • What if we want a function to be dynamically dispatched in two dimensions? • Shape.render(device) vs. Device.render(shape) • void render(virtual device& d, virtual shape& s);??? • d.s.render(); ??? • Multi-Methods allow multidimensional polymorphism • Dylan supports multi-methods • Dispatch mechanism must accommodate all possible combinations • Can require dispatch table: Cartesian product of types – very expensive • Other Solutions • Overloading • Double dispatch Pattern Device::render(Shape& s) { s.render(this); // but shape has to know about different devices }