Template Method and Visitor Patterns (GoF Behavioral)

This page covers two behavioral design patterns from the Gang of Four. Template Method defines the skeleton of an algorithm in a base class, deferring specific steps to subclasses. Visitor represents an operation to be performed on elements of an object structure, allowing new operations without modifying element classes. Both patterns manage the tension between fixed structure and variable behavior, but at different granularities.

Key Concepts

Template Method:

• Defines an algorithm's skeleton in a base class method; subclasses override specific steps (primitive operations) without changing the overall structure
• Embodies the Hollywood Principle: "Don't call us, we'll call you" — the parent class calls subclass operations, not the reverse
• Template methods call five kinds of operations: concrete operations, concrete AbstractClass operations, primitive operations (abstract/must override), factory methods, and hook operations (may override, default to no-op)
• Hooks vs. abstract operations: hooks *may* be overridden (provide default behavior); abstract operations *must* be overridden — subclass writers must understand this distinction
• Fundamental technique for code reuse in class libraries; creates an inverted control structure
• Transforms "call parent explicitly" patterns into parent-controlled extension points, preventing subclasses from forgetting to call the inherited operation

Visitor:

• Separates operations from the object structure they operate on — define new operations by adding visitor subclasses, not by modifying element classes
• Creates two class hierarchies: elements (stable) and visitors (extensible)
• Uses double dispatch: the operation executed depends on both the visitor type and the element type
• The Accept/Visit protocol: element.Accept(visitor) calls visitor.VisitConcreteElement(this)
• Key tradeoff: easy to add new operations, hard to add new element classes (each new element requires updating every visitor)
• Visitors can accumulate state across the traversal without global variables or extra parameters
• May break encapsulation — elements often must expose internal state for visitors to do their job
• Can visit objects that don't share a common parent class (unlike iterators)

Commands and Syntax

Template Method — Hook pattern:

// Parent controls extension via hook
void ParentClass::Operation() {
    // ParentClass behavior
    HookOperation();  // subclass extension point
}
void ParentClass::HookOperation() { }  // default: no-op

void DerivedClass::HookOperation() {
    // derived class extension
}

Template Method — View invariant example:

void View::Display() {
    SetFocus();      // concrete operation (setup)
    DoDisplay();     // hook operation (subclass overrides)
    ResetFocus();    // concrete operation (cleanup)
}

Visitor — Accept/Visit protocol:

class Visitor {
public:
    virtual void VisitElementA(ElementA*);
    virtual void VisitElementB(ElementB*);
protected:
    Visitor();
};

class ElementA : public Element {
public:
    virtual void Accept(Visitor& v) { v.VisitElementA(this); }
};

Visitor — Composite traversal:

void Chassis::Accept(EquipmentVisitor& visitor) {
    for (ListIterator<Equipment*> i(_parts); !i.IsDone(); i.Next()) {
        i.CurrentItem()->Accept(visitor);  // recurse children first
    }
    visitor.VisitChassis(this);  // then visit self
}

Visitor — Client usage:

Equipment* component;
InventoryVisitor visitor;
component->Accept(visitor);
cout << visitor.GetInventory();

Relationships

• Template Method + Factory Method: Template methods often call factory methods as one of their steps (e.g., OpenDocument calls DoCreateDocument)
• Template Method vs. Strategy: Template Method uses *inheritance* to vary part of an algorithm; Strategy uses *delegation* to vary the entire algorithm
• Visitor + Composite: Visitors are commonly applied to composite structures; Accept on composites iterates children before visiting self
• Visitor + Iterator: Traversal responsibility can be in the object structure, the visitor, or a separate iterator; iterators can't cross type hierarchies the way visitors can
• Visitor uses double dispatch: simulates multiple dispatch in single-dispatch languages; some languages (CLOS) support this natively
• Visitor + Interpreter: The Visitor pattern can replace the Interpreter pattern's distributed match/eval operations with centralized visitor classes

Exam-Relevant Points

1. Template Method is about *inheritance-based algorithm customization*; the invariant structure stays in the parent, variable steps are overridden in subclasses

2. Hook operations provide default (often empty) behavior and *may* be overridden; primitive operations are abstract and *must* be overridden — know the difference

3. The Hollywood Principle ("Don't call us, we'll call you") is the defining characteristic of Template Method's inverted control

4. In C++, make the template method non-virtual (cannot be overridden) and primitive operations protected pure virtual

5. Minimize primitive operations — fewer required overrides = easier subclassing

6. Visitor's key tradeoff: easy to add operations, hard to add element types (inverse of standard polymorphism)

7. Double dispatch is the mechanism that makes Visitor work — Accept dispatches on element type, then the Visit call dispatches on visitor type

8. Visitor is appropriate when the element class hierarchy is stable but operations change frequently; if elements change often, put operations in the element classes instead

9. Visitor can accumulate state during traversal (e.g., PricingVisitor accumulates total cost)

10. Three options for traversal responsibility: the object structure (most common), the visitor (for complex/irregular traversals), or a separate iterator

11. Visitor breaks encapsulation — elements must expose enough interface for visitors to work, which may reveal internal state

12. Unlike iterators, visitors can operate on objects without a common parent class