1 / 19

Dynamic Binding

Dynamic Binding. Binding Binding time Motivation Dynamic Binding High Level Methods. Binding Time. Inclusion Polymorphism + Overriding = Binding Question. Binding : linking between messages and methods

edie
Download Presentation

Dynamic Binding

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Dynamic Binding • Binding • Binding time • Motivation • Dynamic Binding • High Level Methods oop

  2. Binding Time Inclusion Polymorphism + Overriding = Binding Question • Binding: linking between messages and methods • The same entity may refer to objects of different classes, each of which has a different implementation of the same method More generally, binding time is the time when an attribute of some portion of a program, or the meaning of a particular construct is determined • Compile Time • Link Time • Execution Time: • Program Init • Procedure/function begin • Statement Execution • Static Binding (AKA Early Binding): the compiler uses the type of variables to do the binding at a compile (link) time • Dynamic Binding (AKA Late Binding): the decision is made at run time based on the type of the actual values oop

  3. Main Binding Techniques Early (static) binding, is the binding of functions in a program at compile time. The programmer knows the type of data for each function called. For example: AddRealNums(x, y) x, y - of type real. Late (dynamic) binding of the message selector to the appropriate method at run time. The programmer doesn't know the specific method that will be used. For example: AddNumbers(x, y) x, y - are number objects. oop

  4. Employee raise_salary print+ Manager print++ Static vs. Dynamic Types • Consider the call: Manager M; M.raise_salary(10); • What is the type of thisin the called method? • Static Type: Employee * • What can be determined in compile time • Dynamic Type: Manager * • Actual type, as determined in run time • No simple way for the programmer to examine the dynamic type • Suppose that raise_salary calls print, then, which version of print will be called? • Based on the static type? or, • Based on the dynamic type? oop

  5. Static vs. Dynamic Binding • Static Binding: binding based on static type. • More efficient • Less flexible • Static type checking leads to safer programs • Dynamic Binding: binding based on dynamic type. • Less efficient • More flexible • May need dynamic type checking! • As it turns out, dynamic binding is the only reasonable choice: • Why? • If static typing is so good, why “spoil” it with dynamic binding? oop

  6. Employee print+ Manager Engineer SalesPerson print++ print++ print++ Motivation I: Containers • #define SIZEOF(a) (sizeof(a)/sizeof(*a)) • ... • Manager Alice, Bob; • Engineer Chuck, Dan, Eve; • SalesPerson Faith, Gil, Hugh; • Employee Ira, Jim, Kelly; • .... • Employee *delegation[] = { &Bob, &Dan, &Faith, &Kelly}; • ... • for (int i = 0; i < SIZEOF(delegation); i++) • delegation[i]->print(cout); Which printshould be called here? oop

  7. Another Container Example • A display list in a graphic application. • List elements: • Objects of subclasses of classShape: • Points, lines, triangles, rectangles, circles, etc. • We want the list to contain elements of type Shape, but each should be capable of preserving its own special properties. • If we loop over the list and send each element in it a draw message, the element should respond according to its “dynamic type”. oop

  8. Shape location draw* hide* move+(delta) Some Shape draw+ hide+ Motivation II: High Level Methods Motivation II: High Level Methods • High Level Methods: methods which are coded using only the publicinterface of a class. • Facilitate code reuse in inheritance. class Shape { Point location;public:... void move(Point delta) { hide(); location += delta; draw(); } ... }; class Rectangle: public Shape { public: void hide(void) const { ... } void draw(void) const { ... } }; Which hideshould be called here? Which drawshould be called here? oop

  9. Shape clone+, draw+ Star clone++, draw++ Motivation III: External Functions void duplicate(const Shape *base) { enum {Dx = 12, Dy = 30}; Shape *clone = base->clone(); clone->move(Dx,Dy); clone->draw(); } Which version of draw() and clone() should be called here? oop

  10. Dynamic Binding is the Answer! • The rule: A called method should be selected based on the actual type of the object it is sent to. • Meaningful only for reference semantics. • Value semantics: dynamic type == static type. • This is why this is a pointer to the object, rather than the object itself. • In a “better C++” this would be a reference to an object. • Archaic C++ code used the idiom this = 0. • All methods in Smalltalk, Eiffel and all other “decent” object-oriented programming languages are dynamically bound. oop

  11. Dynamic Binding in C? void rotate(Shape *p) {switch (p->type) {case rectangle: ... case circle: ... case line: ... ... }} enum Shape_type { rectangle, circle, line, ... }; Strong Coupling struct Shape {int x, y; ... /* Other common fields */ Shape_type type;union {struct Rectangle { ... } r; struct Circle { ... } c; struct Line { ... } l; ... /* Other shape kinds */ } data;}; pointers to functions can be used instead. void draw(Shape *p) {switch (p->type) { case rectangle: ... case circle: ... case line: ... ... }} oop

  12. Disadvantages of the C Solutions • Implicit assumption: consistency between value of the type tag and usage of the union field data. • Programmer’s responsibility: no compiler aid or checking • Dispersed coding: the code for different operations on the same shape is spread all over the program. • Difficult to understand • Insusceptibility to change: whenever a new kind of shape is introduced, the following must be changed: • Definition of Shape_type • Definition of Shape • Function rotate • Function draw • All other functions Some OO programming languages do not include a switch like statement, just because of the above bad usage of switch! oop

  13. The Shapes Example in C++ class Shape {public:virtualvoid draw(void);virtualvoid hide(void);virtualvoid rotate(int deg); ... protected:int x, y; ... /* Other common fields */}; The specialized code is associated with the type, not with each function. OOP promotes the shift of focus from operations to operands class Circle: public Shape {public:virtualvoid draw(void) { ... }virtualvoid hide(void) { ... } //...}; The type tag is hidden, and maintained by the compiler class Line: public Shape {public:virtualvoid draw(void) { ... }virtualvoid hide(void) { ... } //...}; class Rectangle: public Shape {public:virtualvoid draw(void) { ... }virtualvoid hide(void) { ... } //...}; oop

  14. Downcasting vs. Dynamic Binding void draw(Shape *p){ if (Circle *q = dynamic_cast<Circle *>p) { // Draw circle ... } elseif (Line *q = dynamic_cast<Line *>p) { // Draw line ... } elseif (Rectangle *q = dynamic_cast<Rectangle *>p) { // Draw rectangle ... } ... } RTTI considered harmful: • Order of classes in the if chains is significant • Module must change whenever new class is added to the hierarchy oop

  15. Dynamic Binding and the Container Problem • Given is a set of employees as in Employee *department[100]; • Then, how can we determine if a department[3] is a manager or not? • Dynamic Binding Answer: • The question is wrong!!! • There is never a need to determine the dynamic type of an object. • Differences between objects: • Different state • Differences between classes: • Different implementation • Usage of RTTI in all but very special cases indicates a misunderstanding of the power of dynamic binding. oop

  16. High Level Methods Dynamic binding makes methods truly polymorphic. The same code will do different things for different objects: void Shape::move(Point delta){ hide(); location += delta; draw(); } Internal (in-class) dynamic binding • Low level methods: implemented only using data members • code not affected by overriding • High level methods: may use also other methods • partially polymorphic code • Outer level methods: methods implemented solely with (externally accessible) methods • fully polymorphic code oop

  17. Dynamic Binding and Static Typing • Static typing: guarantee that a method exists • A variable of type T can contain only objects of type T, or of type T', where T' is derived from T. • A message to an object is legal only if its static type recognizes it. • Dynamic binding: make sure that the right method is selected. • The method invoked for an object depends on its dynamic type. • Static typing + Dynamic binding: the right combination of safety and power • Examples: Eiffel, C++, Java, Object-Pascal, Turbo-Pascal, etc. oop

  18. C++ Example struct Base {virtualvoid f(void) { ... } void g(void) { ...} }; struct Derived: public Base {virtualvoid f(void) { ...} // Override f() of Base void g(void) { ...} // Override g() of Base void h(void) { ...} } y; Base *px = &y; px->f(); // The right methodpx->g(); // The wrong methodpx->h(); // Compile time error! No guarantee that the method exists oop

  19. Comparison of Binding Techniques • Dynamic binding is more flexible. Static is more efficient. • Static types are more efficient. • Calling static methods is more efficient. • Static method binding may give better error detection, just as static typing gives better error detection. • Usage: • Static binding: homogenous set of objects that are similar to an existing class; inheritance simply makes the new set of objects easier to implement. • Dynamic binding: heterogeneous mix of objects that share operations that are conceptually the same, but may have different implementations. oop

More Related