1 Dynamic Binding

Dynamic binding is a key factor in allowing different classes to respond to the same message with different methods.

• Arguably, no language without dynamic binding is an OOPL

1.1 What is dynamic binding?

Binding is a term used in programming languages to denote the association of information with a symbol. It’s a very general term with many applications.

• a = 2; is a binding of a value to a variable.

• String s; is a binding of a type (String) to the variable name (s).

Binding Function Calls to Bodies

In OOP, we are particularly interested in the
binding of a function body (method) to a function call.

Given the following:

  a = foo(b);

When is the decision made as to what code will be executed for this call to foo?

Compile-Time Binding

  a = foo(b);

In traditionally compiled languages (FORTRAN, PASCAL, C, etc), the decision is made at compile-time.

• Decision is immutable

• If this statement is inside a loop, the same code will be invoked for foo each time.

• Compile-time binding is cheap – there’s very little execution-time overhead.

Run-Time Binding

  a = foo(b);

In traditionally interpreted languages (LISP, BASIC, etc), the decision is made at run-time.

• Decision is often mutable

• If this statement is inside a loop, different code may be invoked for foo each time.

• Run-time binding can be expensive (high execution-time overhead) because it suggests that some sort of decision or lookup is done at each call.

Dynamic Binding = the Happy Medium?

OOPLs typically feature dynamic binding, an “intermediate” choice in which

• the choice of method is made from a relatively small list of options

• that list is determined at compile time

• the final choice made at run-time

• the options that make up that list are organized according to the inheritance hierarchy

Dynamic Binding and Programming Languages

• In Java, all function calls are resolved by dynamic binding.

• In C++, we can choose between compile-time and dynamic binding.

1.2 Dynamic Binding in C++

Virtual functions

• A non-inherited function member is subject to dynamic binding if its declaration is preceded by the word virtual.

• An inherited function member is subject to dynamic binding if that member in the base class is subject to dynamic binding.

• Using the word virtual in subclasses is optional (but recommended).

Dynamic Binding in C++: virtual functions

• Declaring a function as virtual gives programmers permission to call it via dynamic binding.

  • But not all calls will be resolved that way.

• Let foo be a virtual function member.

  • x.foo(), where x is an object, is bound at compile time

  • x.foo(), where x is a reference, is bound at run-time (dynamic).

  • x->{foo()}, where x is a pointer, is bound at run-time (dynamic).

2 An Example of Dynamic Binding

An Animal Inheritance Hierarchy

For this example, we will introduce a simple hierarchy.

class Animal {
public:
  virtual String eats() {return "???";}
  String name() {return "Animal";}
};          

We begin with the base class, Animal, which has two functions.

• One of those functions has been marked virtual, and so is eligible for dynamic binding.

Plant Eaters

Now we introduce a subclass of Animal that overrides both those functions.

class Herbivore: public Animal {
public:
   virtual String eats() {return "plants";}
   String name() {return "Herbivore";}
};

• The “virtual” on function eats is optional.
  • That function is already virtual because it was declared that way in the base class.

    But listing the virtual in the subclass is a nice reminder to the reader.

Cud-Chewers

Now we introduce a subclass of that class.

class Ruminants: public Herbivore {
public:
   virtual String eats() {return "grass";}
   String name() {return "Ruminant";}
};          

Meat Eaters

And another subclass of the original base class.

class Carnivore: public Animal {
public:
   virtual String eats() {return "meat";}
   String name() {return "Carnivore";}
};          

Output Function

It will also be useful in this example to have a simple utility function to print a pair of strings.

void show (String s1, String s2) {
          cout << s1 << " " << s2 << endl;
}          

Let’s Make Some Calls

 Animal a, *paa, *pah, *par;
 Herbivore h, *phh;
 Ruminant r;
 paa = &a; phh = &h; pah = &h; par = &r;
 
 show(a.name(), a.eats());      // AHRC ?pgm
 show(paa->name(), paa->eats()); // AHRC ?pgm
 show(h.name(), h.eats);        // AHRC ?pgm
 show(phh->name(), phh->eats()); // AHRC ?pgm
 show(pah->name(), pah->eats()); // AHRC ?pgm
 show(par->name(), par->eats()); //AHRC ?pgm

• Note that some pointers are initialized to point to objects of a subtype of the pointer’s own declared type.

Note the variety of variables we are using.

• We have three actual objects, a, h, and r, which are of type Animal, Herbivore, and Ruminant, respectively.

• We also have a number of pointers, all of which have names beginning with “p”.

  • The second letter of each pointer variable name indicates its data type.

    Thus, pa, pah, and par are all of type Animal*. ph has type Herbivore*.

  • These pointer variables are all assigned the address of one of our three actual objects. (The unary prefix operator & in C++ is the “address-of” operator.)

  • The third letter in each pointer variable’s name indicates what type of object it actually points to. Thus paa is of type Animal* and actually points to an Animal object, a.

    pah, on the other hand, is of type Animal* but actually points to an Herbivore object, h. (This is possible because of subtyping - we can substitute a subtype object into a context where the supertype object is expected.)

What’s the output?

 Animal a, *paa, *pah, *par;
 Herbivore h, *phh;
 Ruminant r;
 paa = &a; phh = &h; pah = &h; par = &r;
 
 show(a.name(), a.eats());      // AHRC ?pgm
 show(paa->name(), paa->eats()); // AHRC ?pgm
 show(h.name(), h.eats);        // AHRC ?pgm
 show(phh->name(), phh->eats()); // AHRC ?pgm
 show(pah->name(), pah->eats()); // AHRC ?pgm
 show(par->name(), par->eats()); //AHRC ?pgm

Question: What will be the output of the various show calls?

 Animal a, *paa, *pah, *par;
 Herbivore h, *phh;
 Ruminant r;
 paa = &a; phh = &h; pah = &h; par = &r;
 
 show(a.name(), a.eats());<:

:>      // Animal ??? ➀
 show(paa->name(), paa->eats());<:

:> // Animal ??? ➁
 show(h.name(), h.eats);<:

:>        // Herbivore plants ➂
 show(phh->name(), phh->eats());<:

:> // Herbivore plants ➃
 show(pah->name(), pah->eats());<:

:> // Animal plants ➄
 show(par->name(), par->eats());<:

:> //Animal grass ➅

3 Why is Dynamic Binding Important?

Dynamic binding lets us write application code for the superclass that can be applied to the subclasses, taking advantage of the subclasses’ different methods.

3.1 The Key Pattern to All OOP

Collections of Pointers/References to a Base Class

Suppose we have an inheritance hierarchy:

and that we have a collection of pointers or references to the BaseClass.

The Key Pattern to All OOP

Then this code:

BaseClass* x;
for (each x in collection) {
   x->virtualFunction(...);
}

uses dynamic binding to apply subclass-appropriate behavior to each element of a collection.

• Each time around the loop, we extract a pointer from the collection.

• But when we call virtualFunction through that pointer, the runtime system uses the data type of the thing pointed to determine which function body to invoke.

Study this pattern. Once you understand this, you have grasped the essence of OOP!

3.2 Examples of the key pattern

There are lots of variations on this pattern. We can use almost any data structure for the collection.

Example: arrays of Animals

 Animal** animals = new Animal*[numberOfAnimals];
    ⋮
 for (int i = 0; i < numberOfAnimals; ++i)
    cout << animals[i]->name() << " "
        << animals[i]->eats() << endl;

Example: Linked Lists of Animals (C++)

 struct ListNode {
    Animal* data;
    ListNode* next;
 };
 ListNode* head; // start of list
    ⋮
 for (ListNode* current = head; current != 0; current = current->next)
    cout << current->data->name() << " "
         << current->data->eats() << endl;

Example: vector of Animals

 vector<Animal*> animals;
    ⋮
 for (int i = 0; i < animals.size(); ++i)
    cout << animals[i]->name() << " "
         << animals[i]->eats() << endl;

Example: Trees of Animals

 struct TreeNode {
    Animal* data;
    TreeNode* leftChild;
    TreeNode* rightChild;
 };
 TreeNode* root;
 
 void printTree (const TreeNode* t)
 {
   if (t != 0) {
     printTree(t->leftChild);
     cout << t->data->name() << " "
          << t->data->eats() << endl;
     printTree(t->rightChild);
   }
 }
    ⋮
 printTree(root);

4 Examples

4.1 Example: Spreadsheet – Rendering Values

Continuing our earlier example:

4.2 Example: Evaluating a Cell