GoF pg. 221 -222
Iterator GoF pg. 257 – 271
Memento GoF pg. 283-291
By: Dan Sibbernsen
– Concerned with algorithms and responsibilities
– Also concerned with methods of communication
– Allow you to put your “interconnected” hat on
while taking off your “control” hat.
– Provide a means to Iterate through a series of
nodes in specific way(s)
– To traverse lists of information without having to
know anything too specific about the objects
– To implement multiple algorithms to traverse
• Who Controls the Iteration?
– External Iterator
• Client controls iteration
• Client must explicitly request next() on each node
– Internal Iterator
• Iterator controls iteration
• Client hands an operation to the Iterator, Iterator tells
every child in the aggregate to perform it.
• External Iterator
– More flexible than Internal. Can compare 2
• Internal Iterator
– Easier to use, as they define the iteration logic for
you. Makes portability easier.
Who defines the traversal
• Algorithm can be held by a class outside of the
Iterator. It could be held by the aggregate can
– Called “the cursor.”
– Allows the algorithm to access private members of
the aggregate (and not break encapsulation)
• Algorithm is held by the iterator
– Allows algorithms to be swapped out easily.
How Robust is the Iterator?
• If an iterator is robust it
– Will allow for removal of nodes in the middle of
– It does this through registering the iterator with
the aggregate. If any nodes are removed, it is
Additional Iterator Operations
• All come with first, next, isdone, and
– Goes to the previous node that was iterated
– Can be helpful in certain situations
– Skips to a certain node.
– Goes to a node matching specific criteria
Using Polymorphic Iterators in c++
– Allocated dynamically by a factory method.
– Client is responsible for deleting them. Can be
error prone due to multiple levels of calls, and also
because of exceptions
• Proxy can be used to remedy this.
• Only use them when Polymorphism is
Iterators may have privileged
• Makes coupling tighter between Iterator and
• Can be problematic if there are multiple
iterators you want to apply
– Solution: make private iterator-specific functions
“protected” so that only Iterator subclasses can
Iterators for composites
• Use an Internal iterator to keep track of the
levels-deep it has traversed. This happens
recursively so everything is stored on the
• Makes traversal of Composite classes easier.
• Always returns IsDone() as true.
• Factory Method
• “Supports variations in the traversal of an
• “Iterators simplify the Aggregate interface.”
• “More than one traversal can be pending on
– “Without violating encapsulation, capture and
externalize an object’s internal state so that the
object can be restored to this state later.”
– When we want to store off an object’s internal
state without adding any complication to the
– Perhaps for an undo mechanism
Undo Mechanism Complications
• Constraint-Solver problem
– Uses multiple levels deep of objects to draw
– What if we want to support undo but can’t
localize the changes to just one class?
– Propose a Memento that gathers information
from objects contained in a certain class
• Use this
– when you want to save state on a hierarchy’s
– When the hierarchy’s interface would be broken if
implementation details were exposed.
– stores the state of the Originator
– Creates the memento
– “Uses the memento to restore its internal state”
– Keeps track of the Memento
– Never uses the Memento’s Interface to the
• Pg. 286 (can’t find image)
• Caretaker requests a memento from an
• Caretaker passes back memento.
• Originator uses it to restore state.
• “Preserves Encapsulation Boundaries”
• “It simplifies Originator”
• You can name your class
• Might be expensive
• Difficulty defining interfaces to keep
• Hidden costs in caring for mementos
– Caretaker could have to keep track of a lot of
information for the memento
• You can name your class
• Language Support
– C++ lets you call Originator a friend of Memento,
thus giving it access to all private members of
Memento that it needs
Storing Incremental Changes
• If storing state happens incrementally, then
we can just record the changes of what’s
happened in a new memento object.
• This helps with memory difficulties.