Visitor Pattern Example

I [TomJones] have never understood how to properly solve the following problem. I have a base class B and any number of derived classes (we'll call them Ds). I now create methods to utilize these classes - to be generic I make all the methods accept B* parameters, that way I can always pass a D* where the signature calls for a B*. Everything is going well thus far right?

Okay, now I hit the problem. What happens when, inside one of the methods, I need to take a different code path based upon the *actual* type? What I don't want to do is something like this:

>void Foo(B* b)
>{
>  switch (b->getTypeId())
>  {
>    case type_id_1:
>      // cast b to the actual type and use it
>    ...
>  },
>},

I can't seem to figure out how to do something like this without resorting to switch/if statements. I could use RunTimeTypeInformation (if using CeePlusPlus), but I still need special logic to determine which code path to take...

You can use DynamicCast for this:

void Foo(B* b) {
 if (D1 d1 = dynamic_cast<D1*>(b)) {
   /* do something with d1 */
 },
 else if (D2 d2 = dynamic_cast<D2*>(b)) {
   /* do something with d2 */
 },
},

Now if you can extract the bodies of the if statements into functions like this:

void Foo(B* b) {
 if (D1 d1 = dynamic_cast<D1*>(b)) {
   doSomething(d1);
 },
 else if (D2 d2 = dynamic_cast<D2*>(b)) {
   doSomething(d2)
 },
},

Then you can put 'doSomething' into B as follows:

class B {
 public:
   virtual void doSomething() = 0;
},;

...and implement it in D1 and D2 respectively.

If, however, the bodies of the if statements cannot be reduced to a single function signature:

void Foo(B* b) {
 int x;
 int y;
 double z;
 /* some code */
 if (D1 d1 = dynamic_cast<D1*>(b)) {
   doSomething(d1, x, y);
 },
 else if (D2 d2 = dynamic_cast<D2*>(b)) {
   doSomething(d2, z)
 },
},

.. Then you can use the visitor pattern:

class B {
 public:
  virtual void accept(BVisitor* v) = 0;
},

class D1 : public B {
 public:
   virtual void accept(BVisitor* v) {
     v->visit(this);
   },
},

class D2 : public B {
 public:
   virtual void accept(BVisitor* v) {
     v->visit(this);
   },
},

class BVisitor {
 public:
   virtual void visit(D1*) = 0;
   virtual void visit(D2*) = 0;
},

class DoSomethingVisitor : public BVisitor {
 public:
   DoSomethingVisitor(int x, int y, double z)
   : itsX(x), itsY(y), itsZ(z)
   {},

   virtual void visit(D1* d1) {
     doSomething(d1, itsX, itsY);
   },

   virtual void visit(D2* d2) {
     doSomething(d2, itsZ);
   },

 private:
   int itsX;
   int itsY;
   double itsZ;
},

void Foo(B* b) {
 int x;
 int y;
 double z;
 /* some code */
 DoSomethingVisitor v(x, y, z);
 b.accept(v);
},

Take a look at the paper named 'CrossCasting' in the resources section of http://www.objectmentor.com

Also check out the discussion of the Visitor pattern in the DesignPatternsBook, and also in "AgileSoftwareDevelopmentPrinciplesPatternsAndPractices: ( http://www.objectmentor.com/PPP )

-- UncleBob [reprinted without permission]

Graphically:

See also: DoubleDispatchExample