// Purpose. Visitor (adding ops) #include <iostream.h>
// class Visitor;
// Discussion. On the left, adding
// new operations requires modifying class Color { public:
// all the current Color classes. If virtual void accept( Visitor& ) = 0;
// we introduce an extra level of in- };
// direction (a Visitor hierarchy),
// then operations capable of opera- class Red : public Color { public:
// ting on Color classes can be added void accept( Visitor& );
// without modifying any existing void eye() { cout << "Red::eye\n"; }
// code. On the right, an entry point };
// for all future operations has been class Blu : public Color { public:
// added in the form of the accept() void accept( Visitor& );
// method. Each of the previous op- void sky() { cout << "Blu::sky\n"; }
// erations has been encapsulated in };
// its own derived Visitor class. Any
// new operations simply require the class Visitor { public:
// addition of a new Visitor class. virtual void visit( Red& ) = 0;
// virtual void visit( Blu& ) = 0;
// When we call accept() on a Color };
// object, dynamic binding gets us to
// the correct derived class of Color. class CountV : public Visitor {
// Then when we call visit() on the public:
// Visitor object, dynamic binding CountV() { numRed_ = numBlu_ = 0; }
// gets us to the correct derived virtual void visit( Red& ) {
// class of Visitor. [Visitors and numRed_++; }
// Colors can be passed by address or virtual void visit( Blu& ) {
// passed by reference.] numBlu_++; }
void reportNum() {
#include <iostream.h> cout << "Reds " << numRed_ <<
", Blus " << numBlu_ << endl; }
class Color { private:
public: int numRed_, numBlu_;
virtual void count() = 0; };
virtual void call() = 0;
static void reportNum() { class CallV : public Visitor { public:
cout << "Reds " << numRed_ << virtual void visit( Red& r ) {
", Blus " << numBlu_ <<endl; } r.eye(); }
protected: virtual void visit( Blu& b ) {
static int numRed_, numBlu_; b.sky(); }
}; };
int Color::numRed_ = 0;
int Color::numBlu_ = 0; void Red::accept( Visitor& v ) {
v.visit( *this ); }
class Red : public Color { public: void Blu::accept( Visitor& v ) {
void count() { numRed_++; } v.visit( *this ); }
void call() { eye(); }
void eye() { cout << "Red::eye\n";} void main( void )
}; {
Color* set[] = { new Red, new Blu,
class Blu : public Color { public: new Blu, new Red, new Red, 0 };
void count() { numBlu_++; } CountV countOp;
void call() { sky(); } CallV callOp;
void sky() { cout << "Blu::sky\n";} for (int i=0; set[i]; i++) {
}; set[i]->accept( countOp );
set[i]->accept( callOp ); }
void main( void ) countOp.reportNum();
{ }
Color* set[] = { new Red, new Blu,
new Blu, new Red, new Red, 0 }; // Red::eye
for (int i=0; set[i]; i++) { // Blu::sky
set[i]->count(); // Blu::sky
set[i]->call(); } // Red::eye
Color::reportNum(); // Red::eye
} // Reds 3, Blus 2




// Purpose. Visitor (double dispatch)
//
// Discussion. On the left, the State derived classes must query the type of
// the Cmd objects they receive, in order to identify what the next course of
// action is. "case" stmts are always a maintenance headache. On the right,
// we have recognized that what we really want to do is "dispatch" based on
// the type of TWO objects, (a State object and a Cmd object). The call to
// accept() discriminates the type of the State object that is being messaged,
// and then the call to visit() discriminates the type of the Cmd object
// (while passing the type of the State object). If new Cmd classes are
// added, no change whatsoever is necessary in the code of the State classes.
// If new State classes are added, then every Cmd class must be changed, and
// Visitor is NOT the right approach to take.

#include <iostream.h> #include <iostream.h>
int current = 0; int current = 0;
enum CmdTyp { OnT, OffT }; class One; class Two;

class Cmd { public: class Cmd { public:
virtual CmdTyp typ() = 0; virtual void visit( One* ) {
}; cout << "ERROR\n"; }
class On : public Cmd { public: virtual void visit( Two* ) {
CmdTyp typ() { return OnT; } cout << "ERROR\n"; }
}; };
class Off : public Cmd { public: class On : public Cmd { public:
CmdTyp typ() { return OffT; } void visit( One* ) {
}; current = 1;
cout << "One,On => Two\n"; }
class State { public: void visit( Two* t ) {
virtual void process( Cmd* c ) { Cmd::visit( t ); }
cout << "ERROR\n"; } };
}; class Off : public Cmd { public:
class One : public State { public: void visit( One* o ) {
void process( Cmd* c ) { Cmd::visit( o ); }
if (c->typ() == OnT) { void visit( Two* ) {
current = 1; current = 0;
cout << "One,On => Two\n"; } cout << "Two,Off => One\n"; }
else if (c->typ() == OffT) };
State::process( c );
} class State { public:
}; virtual void accept( Cmd* c ) = 0;
class Two : public State { public: };
void process( Cmd* c ) { class One : public State { public:
if (c->typ() == OnT) void accept( Cmd* c ) {
State::process( c ); c->visit( this ); }
else if (c->typ() == OffT) { };
current = 0; class Two : public State { public:
cout << "Two,Off => One\n"; } void accept( Cmd* c ) {
} c->visit( this ); }
}; };

State* states[] = { new One, new Two }; State* states[] = { new One, new Two };

void main( void ) void main( void )
{ {
Cmd* c[] = { new Off, Cmd* c[] = { new Off,
new On, new Off, new Off, 0 }; new On, new Off, new Off, 0 };
for (int i=0; c[i]; i++) for (int i=0; c[i]; i++)
states[current]->process( c[i] ); states[current]->accept( c[i] );
} }

// ERROR // ERROR
// One,On => Two // One,On => Two
// Two,Off => One // Two,Off => One
// ERROR // ERROR




// Purpose. Visitor design pattern

// 1. Add an accept(Visitor) method to the "element" hierarchy
// 2. Create a "visitor" base class w/ a visit() method for every "element" type
// 3. Create a "visitor" derived class for each "operation" to do on "elements"
// 4. Client creates "visitor" objects and passes each to accept() calls

#include <iostream>
#include <string>
using namespace std;

// 1. Add an accept(Visitor) method to the "element" hierarchy
class Element { public:
virtual void accept( class Visitor& v ) = 0;
};

class This : public Element { public:
/*virtual*/ void accept( Visitor& v );
string thiss() { return "This"; }
};

class That : public Element { public:
/*virtual*/ void accept( Visitor& v );
string that() { return "That"; }
};

class TheOther : public Element { public:
/*virtual*/ void accept( Visitor& v );
string theOther() { return "TheOther"; }
};

// 2. Create a "visitor" base class w/ a visit() method for every "element" type
class Visitor { public:
virtual void visit( This* e ) = 0;
virtual void visit( That* e ) = 0;
virtual void visit( TheOther* e ) = 0;
};

/*virtual*/ void This::accept( Visitor& v ) { v.visit( this ); }
/*virtual*/ void That::accept( Visitor& v ) { v.visit( this ); }
/*virtual*/ void TheOther::accept( Visitor& v ) { v.visit( this ); }

// 3. Create a "visitor" derived class for each "operation" to do on "elements"
class UpVisitor : public Visitor {
/*virtual*/ void visit( This* e ) {
cout << "do Up on " + e->thiss() << '\n'; }
/*virtual*/ void visit( That* e ) {
cout << "do Up on " + e->that() << '\n'; }
/*virtual*/ void visit( TheOther* e ) {
cout << "do Up on " + e->theOther() << '\n'; }
};

class DownVisitor : public Visitor {
/*virtual*/ void visit( This* e ) {
cout << "do Down on " + e->thiss() << '\n'; }
/*virtual*/ void visit( That* e ) {
cout << "do Down on " + e->that() << '\n'; }
/*virtual*/ void visit( TheOther* e ) {
cout << "do Down on " + e->theOther() << '\n'; }
};

void main( void ) {
Element* list[] = { new This(), new That(), new TheOther() };
UpVisitor up; // 4. Client creates
DownVisitor down; // "visitor" objects
for (int i=0; i < 3; i++) // and passes each
list[i]->accept( up ); // to accept() calls
for (i=0; i < 3; i++)
list[i]->accept( down );
}

// do Up on This // do Down on This
// do Up on That // do Down on That
// do Up on TheOther // do Down on TheOther




// Purpose. Visitor - recovering lost type information
//
// Motivation. "My Component classes do not know that Composites exist.
// They provide no help for navigating Composites, nor any help for
// altering the contents of a Composite. This is because I would like the
// base class (and all its derivatives) to be reusable in contexts that do
// not require Composites. When given a base class pointer, if I
// absolutely need to know whether or not it is a Composite, I will use
// dynamic_cast() to figure this out. In those cases where dynamic_cast()
// is too expensive, I will use a Visitor." [Robert Martin]

#include <iostream>
#include <vector>
using namespace std;

class Visitor { public:
virtual void visit( class Primitive*, class Component* ) = 0;
virtual void visit( class Composite*, Component* ) = 0;
};

class Component {
int value;
public:
Component( int val ) { value = val; }
virtual void traverse() { cout << value << " "; }
// Having add() here sacrifices safety, but it supports transparency
// virtual void add( Component* ) { }
virtual void accept( Visitor&, Component* ) = 0;
};

class Primitive : public Component { public:
Primitive( int val ) : Component( val ) { }
/*virtual*/ void accept( Visitor& v, Component* c ) { v.visit( this, c ); }
};

class Composite : public Component {
vector<Component*> children;
public:
Composite( int val ) : Component( val ) { }
void add( Component* ele ) { children.push_back( ele ); }
/*virtual*/ void accept( Visitor& v, Component* c ) { v.visit( this, c ); }
/*virtual*/ void traverse() {
Component::traverse();
for (int i=0; i < children.size(); i++)
children[i]->traverse();
} };

class AddVisitor : public Visitor { public:
/*virtual*/ void visit( Primitive*, Component* ) {/* does not make sense */}
/*virtual*/ void visit( Composite* node, Component* c ) { node->add( c ); }
};

void main( void ) {
Component* nodes[3];
// The type of Composite* is "lost" when the object is assigned to a
// Component*
nodes[0] = new Composite(1);
nodes[1] = new Composite(2);
nodes[2] = new Composite(3);

// If add() were in class Component, this would work
// nodes[0]->add( nodes[1] );
// If it is NOT in Component, and only in Composite, you get the error -
// no member function `Component::add(Component *)' defined

// Instead of sacrificing safety, we use a Visitor to support add()
AddVisitor addVisitor;
nodes[0]->accept( addVisitor, nodes[1] );
nodes[0]->accept( addVisitor, nodes[2] );
nodes[0]->accept( addVisitor, new Primitive(4) );
nodes[1]->accept( addVisitor, new Primitive(5) );
nodes[1]->accept( addVisitor, new Primitive(6) );
nodes[2]->accept( addVisitor, new Primitive(7) );

for (int i=0; i < 3; i++) {
nodes[i]->traverse();
cout << endl;
} }

// 1 2 5 6 3 7 4
// 2 5 6
// 3 7




// Purpose. Combining Visitor with Composite's recursive traversal

#include <iostream>
#include <vector>
using namespace std;

class Visitor { public:
virtual void visit( class Leaf* e ) = 0;
virtual void visit( class Composite* e ) = 0;
};

class Component { public:
virtual void traverse() = 0;
virtual void accept( class Visitor& v ) = 0;
};

class Leaf : public Component {
int value;
public:
Leaf( int val ) { value = val; }
/*virtual*/ void traverse() { cout << value << ' '; }
/*virtual*/ void accept( class Visitor& v ) { v.visit( this ); }
int getValue() { return value; }
};

class Composite : public Component {
char value;
vector<Component*> children;
static char next;
public:
Composite() { value = next++; }
void add( Component* ele ) { children.push_back( ele ); }
/*virtual*/ void traverse() {
cout << value << ' ';
for (int i=0; i < children.size(); i++)
children[i]->traverse();
}
/*virtual*/ void accept( class Visitor& v ) {
v.visit( this );
// accept() has been embellished to include the logic in traverse()
for (int i=0; i < children.size(); i++)
children[i]->accept( v );
}
char getValue() { return value; }
};
char Composite::next = 'a';

class TransformVisitor : public Visitor { public:
/*virtual*/ void visit( Leaf* e ) { cout << e->getValue() + 100 << ' '; }
/*virtual*/ void visit( Composite* e ) { cout << (char)(e->getValue()-32) <<' ';}
};

void main( void ) {
Composite containers[4];
for (int i=0; i < 4; i++)
for (int j=0; j < 3; j++)
containers[i].add( new Leaf( i * 3 + j ) );
for (i=1; i < 4; i++) containers[0].add( &(containers[i]) );

containers[0].traverse(); cout << endl;

TransformVisitor tv;
// don't need an "iteration" capability with this design
containers[0].accept( tv ); cout << endl;
}

// a 0 1 2 b 3 4 5 c 6 7 8 d 9 10 11
// A 100 101 102 B 103 104 105 C 106 107 108 D 109 110 111




// Purpose. Undesireable design - double dispatch - doing the right thing based
// on the type of two objects

#include <iostream>
#include <string>
using namespace std;

class Request { public: virtual string getType() = 0; };

class R1 : public Request { public:
/*virtual*/ string getType() { return "One"; }
void reqOneMethod( class P1* );
void reqOneMethod( class P2* );
};
class R2 : public Request { public:
/*virtual*/ string getType() { return "Two"; }
void reqTwoMethod( P1* );
void reqTwoMethod( P2* );
};

class Processor { public: virtual void handle( class Request* ) = 0; };

class P1 : public Processor { public:
/*virtual*/ void handle( class Request* req ) {
if (req->getType() == string("One")) ((R1*)req)->reqOneMethod( this );
else if (req->getType() == string("Two")) ((R2*)req)->reqTwoMethod( this );
}
void procOneMethod() { cout << "processor one handling "; }
};
class P2 : public Processor { public:
/*virtual*/ void handle( class Request* req ) {
if (req->getType() == string("One")) ((R1*)req)->reqOneMethod( this );
else if (req->getType() == string("Two")) ((R2*)req)->reqTwoMethod( this );
}
void procTwoMethod() { cout << "processor two handling "; }
};

void R1::reqOneMethod( P1* p ) { p->procOneMethod(); cout << "request one\n"; }
void R1::reqOneMethod( P2* p ) { p->procTwoMethod(); cout << "request one\n"; }
void R2::reqTwoMethod( P1* p ) { p->procOneMethod(); cout << "request two\n"; }
void R2::reqTwoMethod( P2* p ) { p->procTwoMethod(); cout << "request two\n"; }

void main( void ) {
Processor* handlers[] = { new P1(), new P2() };
Request* commands[] = { new R1(), new R2() };
for (int i=0; i < 2; i++)
for (int j=0; j < 2; j++)
handlers[i]->handle( commands[j] );
}

// processor one handling request one
// processor one handling request two
// processor two handling request one
// processor two handling request two




// Purpose. Visitor - double dispatch - doing the right thing based on the
// type of two objects

#include <iostream>
#include <string>
using namespace std;

class Request { public:
// second dispatch - the "visit()" method
virtual void execute( class P1* ) = 0;
virtual void execute( class P2* ) = 0;
};
class R1 : public Request { public:
/*virtual*/ void execute( P1* );
/*virtual*/ void execute( P2* );
};
class R2 : public Request { public:
/*virtual*/ void execute( P1* );
/*virtual*/ void execute( P2* );
};

class Processor { public:
// first dispatch - the "accept()" method
virtual void handle( class Request* ) = 0;
};
class P1 : public Processor { public:
/*virtual*/ void handle( Request* req ) { req->execute( this ); }
void procOneMethod() { cout << "processor one handling "; }
};
class P2 : public Processor { public:
/*virtual*/ void handle( Request* req ) { req->execute( this ); }
void procTwoMethod() { cout << "processor two handling "; }
};

/*virtual*/ void R1::execute( P1* p ) { p->procOneMethod(); cout << "request one\n"; }
/*virtual*/ void R1::execute( P2* p ) { p->procTwoMethod(); cout << "request one\n"; }
/*virtual*/ void R2::execute( P1* p ) { p->procOneMethod(); cout << "request two\n"; }
/*virtual*/ void R2::execute( P2* p ) { p->procTwoMethod(); cout << "request two\n"; }

void main( void ) {
Processor* handlers[] = { new P1(), new P2() };
Request* commands[] = { new R1(), new R2() };
for (int i=0; i < 2; i++)
for (int j=0; j < 2; j++)
handlers[i]->handle( commands[j] );
}

// processor one handling request one
// processor one handling request two
// processor two handling request one
// processor two handling request two




// Purpose. Acyclic Visitor design pattern [PLOPD vol 3, p93]
//
// Problem. In GOF Visitor, Element depends on Visitor, Visitor depends on
// all Element derivatives, and Element derivatives depend on Element; this is
// cyclic dependency. Additionally, adding an Element derivative requires the
// entire Visitor hierarchy to change. "These problems can be solved by using
// multiple inheritance and dynamic_cast()."
//
// Solution. Element derived classes are only coupled to Visitor base class.
// Visitor derived classes are only coupled to the Element derived classes that
// they choose to be coupled to. If a new Element derived class is added,
// Visitor derived classes can update themselves if, and when, they choose.

#include <iostream>
#include <string>
using namespace std;

class Element { public:
virtual void accept( class Visitor& v ) = 0;
};

class This : public Element { public:
/*virtual*/ void accept( Visitor& v );
string thiss() { return "This"; }
};

class That : public Element { public:
/*virtual*/ void accept( Visitor& v );
string that() { return "That"; }
};

class TheOther : public Element { public:
/*virtual*/ void accept( Visitor& v );
string theOther() { return "TheOther"; }
};

class Visitor { public:
virtual ~Visitor() { };
};
class ThisVisitor { public:
virtual void visit( This* e ) = 0;
};
class ThatVisitor { public:
virtual void visit( That* e ) = 0;
};
class TheOtherVisitor { public:
virtual void visit( TheOther* e ) = 0;
};

/*virtual*/ void This::accept( Visitor& v ) {
ThisVisitor* tv = dynamic_cast<ThisVisitor*>( &v );
if (tv) tv->visit( this );
else cout << "the visitor was not accepted\n";
}
/*virtual*/ void That::accept( Visitor& v ) {
ThatVisitor* tv = dynamic_cast<ThatVisitor*>( &v );
if (tv) tv->visit( this );
else cout << "the visitor was not accepted\n";
}
/*virtual*/ void TheOther::accept( Visitor& v ) {
TheOtherVisitor* tv = dynamic_cast<TheOtherVisitor*>( &v );
if (tv) tv->visit( this );
else cout << "the visitor was not accepted\n";
}

class UpVisitor : public Visitor, public ThisVisitor, public ThatVisitor,
public TheOtherVisitor {
/*virtual*/ void visit( This* e ) {
cout << "do Up on " + e->thiss() << '\n'; }
/*virtual*/ void visit( That* e ) {
cout << "do Up on " + e->that() << '\n'; }
/*virtual*/ void visit( TheOther* e ) {
cout << "do Up on " + e->theOther() << '\n'; }
};

class DownVisitor : public Visitor, public ThisVisitor, public ThatVisitor,
public TheOtherVisitor {
/*virtual*/ void visit( This* e ) {
cout << "do Down on " + e->thiss() << '\n'; }
/*virtual*/ void visit( That* e ) {
cout << "do Down on " + e->that() << '\n'; }
/*virtual*/ void visit( TheOther* e ) {
cout << "do Down on " + e->theOther() << '\n'; }
};

void main( void ) {
Element* list[] = { new This(), new That(), new TheOther() };
UpVisitor up; // 4. Client creates
DownVisitor down; // "visitor" objects
for (int i=0; i < 3; i++) // and passes each
list[i]->accept( up ); // to accept() calls
for (i=0; i < 3; i++)
list[i]->accept( down );
}

// do Up on This // do Down on This
// do Up on That // do Down on That
// do Up on TheOther // do Down on TheOther




// Purpose. Double dispatch (within a single hierarchy)
//
// Discussion. We would like to declare a function like:
// void process( virtual Base* object1, virtual Base* object2 )
// that does the right thing based on the type of 2 objects that come from
// a single inheritance hierarchy. The only problem is that the keyword
// "virtual" may not be used to request dynamic binding for an object being
// passed as an argument. C++ will only "discriminate" the type of an object
// being messaged, not the type of an object being passed. So in order for
// the type of 2 objects to be discriminated, each object must be the
// receiver of a virtual function call. Here, when process1() is called on
// the first object, its type becomes "known" at runtime, but the type of
// the second is still UNknown. process2() is then called on the second
// object, and the identity (and type) of the first object is passed as an
// argument. Flow of control has now been vectored to the spot where the
// type (and identity) of both objects are known.

#include <iostream>
using namespace std;

class Base { public:
virtual void process1( Base& ) = 0;
virtual void process2( class A& ) = 0;
virtual void process2( class B& ) = 0;
virtual void process2( class C& ) = 0;
};

class A : public Base { public:
/*virtual*/ void process1( Base& second ) { second.process2( *this ); }
/*virtual*/ void process2( class A& first ) {
cout << "first is A, second is A\n"; }
/*virtual*/ void process2( class B& first ) {
cout << "first is B, second is A\n"; }
/*virtual*/ void process2( class C& first ) {
cout << "first is C, second is A\n"; }
};

class B : public Base { public:
/*virtual*/ void process1( Base& second ) { second.process2( *this ); }
/*virtual*/ void process2( class A& first ) {
cout << "first is A, second is B\n"; }
/*virtual*/ void process2( class B& first ) {
cout << "first is B, second is B\n"; }
/*virtual*/ void process2( class C& first ) {
cout << "first is C, second is B\n"; }
};

class C : public Base { public:
/*virtual*/ void process1( Base& second ) { second.process2( *this ); }
/*virtual*/ void process2( class A& first ) {
cout << "first is A, second is C\n"; }
/*virtual*/ void process2( class B& first ) {
cout << "first is B, second is C\n"; }
/*virtual*/ void process2( class C& first ) {
cout << "first is C, second is C\n"; }
};

void main( void ) {
Base* array[] = { &A(), &B(), &C() };
for (int i=0; i < 3; i++)
for (int j=0; j < 3; j++)
array[i]->process1( *array[j] );
}

// first is A, second is A
// first is A, second is B
// first is A, second is C
// first is B, second is A
// first is B, second is B
// first is B, second is C
// first is C, second is A
// first is C, second is B
// first is C, second is C




// Purpose. Triple dispatch (within a single hierarchy)
//
// Discussion. It would be nice if C++ supported creating a function like:
// "processCombine( virtual Binary& first, virtual Binary& second, virtual
// Binary& third )". While not directly supported, we can simulate this kind
// of capability by: calling combine() on the first object to resolve its
// type, then calling combine() on the second object to resolve its type,
// then calling combine() on the third object to resolve its type. We
// "remember" the type information we have "discriminated" at each stage by
// juggling the three objects through 2 increasingly type-specific parameter
// slots.

#include <iostream>
using namespace std;

class Zero;
class One;

class Binary {
public:
// First dispatch
virtual void combine( Binary& second, Binary& third ) = 0;

// Second dispatch
virtual void combine( Binary& third, Zero& first ) = 0;
virtual void combine( Binary& third, One& first ) = 0;

// Third dispatch
virtual void combine( Zero& first, Zero& second ) = 0;
virtual void combine( Zero& first, One& second ) = 0;
virtual void combine( One& first, Zero& second ) = 0;
virtual void combine( One& first, One& second ) = 0;
};

class Zero : public Binary {
public:
void combine( Binary& second, Binary& third ) {
second.combine( third, *this ); }

void combine( Binary& third, Zero& first ) {
third.combine( first, *this ); }
void combine( Binary& third, One& first ) {
third.combine( first, *this ); }

void combine( Zero& first, Zero& second );
void combine( Zero& first, One& second );
void combine( One& first, Zero& second );
void combine( One& first, One& second );

void doZero() { cout << "0 "; }
};

class One : public Binary {
public:
void combine( Binary& second, Binary& third ) {
second.combine( third, *this ); }

void combine( Binary& third, Zero& first ) {
third.combine( first, *this ); }
void combine( Binary& third, One& first ) {
third.combine( first, *this ); }

void combine( Zero& first, Zero& second );
void combine( Zero& first, One& second );
void combine( One& first, Zero& second );
void combine( One& first, One& second );

void doOne() { cout << "1 "; }
};

void Zero::combine( Zero& first, Zero& second ) {
first.doZero(); second.doZero(); doZero(); cout << endl; }
void Zero::combine( Zero& first, One& second ) {
first.doZero(); second.doOne(); doZero(); cout << endl; }
void Zero::combine( One& first, Zero& second ) {
first.doOne(); second.doZero(); doZero(); cout << endl; }
void Zero::combine( One& first, One& second ) {
first.doOne(); second.doOne(); doZero(); cout << endl; }

void One::combine( Zero& first, Zero& second ) {
first.doZero(); second.doZero(); doOne(); cout << endl; }
void One::combine( Zero& first, One& second ) {
first.doZero(); second.doOne(); doOne(); cout << endl; }
void One::combine( One& first, Zero& second ) {
first.doOne(); second.doZero(); doOne(); cout << endl; }
void One::combine( One& first, One& second ) {
first.doOne(); second.doOne(); doOne(); cout << endl; }

void processCombine( Binary& first, Binary& second, Binary& third ) {
first.combine( second, third );
}

void main( void ) {
Binary* list[2] = { &Zero(), &One() };

// Run through permutations
for (int i=0; i < 2; i++)
for (int j=0; j < 2; j++)
for (int k=0; k < 2; k++)
processCombine( *list[i], *list[j], *list[k] );
}

// 0 0 0
// 0 0 1
// 0 1 0
// 0 1 1
// 1 0 0
// 1 0 1
// 1 1 0
// 1 1 1