1 The Variant Behavior Pattern

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.

Apply a Virtual Function to Each Element

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.

  Thanks to subtyping, that pointer could be pointing to something of type BaseClass or to any of its subclasses.

• 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.

  If we have enough subclasses, we could wind up doing a different function body each time around the loop.

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

2 Simple Examples of the Variant Behavior pattern

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

2.1 Arrays of Animals

Suppose that we have an array of pointers to animals:

C++

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

Java

Animal[] animals = new Animal[numberOfAnimals];
   ⋮
for (Animal a: animals)
   System.out.println (a.name() + " " + a.eats());

We assume that in the ⋮ area, those arrays get filled with appropriate pointer values. For example,

Animal** animals = new Animal*[numberOfAnimals];

for (int i = 0; i < numberOfAnimals; ++i)
{
   char c;
   cin >> c;
   if (c =='A')
       animals[i] = new Animal();
   else if (c =='C')
       animals[i] = new Carnivore();
   else if (c =='H')
       animals[i] = new Herbivore();
   else if (c =='R')
       animals[i] = new Ruminant();
}

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

in which case, after an input of AHCR, we would get output

animal ???
animal plants
animal meat
animal grass

although the equivalent Java code would print

animal ???
herbivore plants
carnivore meat
ruminant grass

because, in Java, both the name() and eats() functions are virtual.

2.2 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;

Java

class ListNode {
   Animal data;
   ListNode next;
}
ListNode head; // start of list
   ⋮
for (ListNode current = head; current != null; 
       current = current.next)
   System.out.println (current.name() 
       + " " + current.eats());

• Notice, once again, the complete lack of * or -> operators.
  • C++ programmers are used to seeing those as cues that they are dealing with pointers.

2.3 Vectors of Animals

C++

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

or

vector<Animal*> animals;
   ⋮
for (Animal* p: animals)
   cout << p->name() << " "
       << p->eats() << endl;

Java

ArrayList<Animal> animals = new ArrayList<Animal>();
   ⋮
for (int i = 0; i < animals.size(); ++i) {
   Animal a = animals.get(i);
   System.out.println (a.name() + " " + a.eats());
}

or

ArrayList<Animal> animals = new ArrayList<Animal>();
   ⋮
for (Animal a: animals) {
   System.out.println (a.name() + " " + a.eats());
}

2.4 Example: Trees of Animals

C++

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

Java

 class TreeNode {
    public Animal data;
    public TreeNode leftChild;
    public TreeNode rightChild;
 }
 TreeNode root;
 
 void printTree (TreeNode t)
 {
   if (t != null) {
     printTree(t.leftChild);
     System.out.println (
         t.data.name() + " "
         + t.data.eats() );
     printTree(t.rightChild);
   }
 }
    ⋮
 printTree(root);

This example is a touch more subtle. There’s no loop, but the essential idea is the same. We are still iterating over a collection (in this case, using recursive calls), obtaining at each step a pointer that can point to any of several types in an inheritance hierarchy, and using that pointer to invoke a virtual function.

2.5 Summary

In all of these examples, the data structure for the collection is pretty much irrelevant. The important factors are that

• It must be a collection of pointers/references, not direct copies of objects.

  This is pretty much a given in Java, but we have to watch for this in C++.

• The iteration must apply a virtual function to each element in the collection.

  Nearly all functions are virtual in Java, but again we have to check for this in C++.

3 Larger Examples

3.1 Example: Spreadsheet – Rendering Values

Continuing our earlier example:

3.2 Example: Evaluating a Cell

const Value* Cell::evaluateFormula()
{
  Value* newValue = (theFormula == 0)
    ? new StringValue()
    : theFormula->evaluate(theSheet);

  if (theValue != 0 && *newValue == *theValue)
    delete newValue;
  else
    {
      delete theValue;
      theValue = newValue;
      notifyObservers();
    }
  return theValue;
}

• After evaluating a formula in a spreadsheet cell we check to see if the value obtained is equal to theValue already stored in that cell.

  • If the values are equal, we simply discard the newly computed value. We don’t need it.

  • But if they are not equal, we need to save the new value in place of the old one and trigger the re-evaluation of any cells that mention this one in their formulas.

(The exact mechanism for how that trigger works will be explored later.)

operator==

Look at the implementation of operator== in