When should I use the Visitor Design Pattern? [closed]

by

I’m not very familiar with the Visitor pattern. Let’s see if I got it right. Suppose you have a hierarchy of animals

class Animal {  };
class Dog: public Animal {  };
class Cat: public Animal {  };

(Suppose it is a complex hierarchy with a well-established interface.)

Now we want to add a new operation to the hierarchy, namely we want each animal to make its sound. As far as the hierarchy is this simple, you can do it with straight polymorphism:

class Animal
{ public: virtual void makeSound() = 0; };

class Dog : public Animal
{ public: void makeSound(); };

void Dog::makeSound()
{ std::cout << "woof!\n"; }

class Cat : public Animal
{ public: void makeSound(); };

void Cat::makeSound()
{ std::cout << "meow!\n"; }

But proceeding in this way, each time you want to add an operation you must modify the interface to every single class of the hierarchy. Now, suppose instead that you are satisfied with the original interface, and that you want to make the fewest possible modifications to it.

The Visitor pattern allows you to move each new operation in a suitable class, and you need to extend the hierarchy’s interface only once. Let’s do it. First, we define an abstract operation (the “Visitor” class in GoF) which has a method for every class in the hierarchy:

class Operation
{
public:
    virtual void hereIsADog(Dog *d) = 0;
    virtual void hereIsACat(Cat *c) = 0;
};

Then, we modify the hierarchy in order to accept new operations:

class Animal
{ public: virtual void letsDo(Operation *v) = 0; };

class Dog : public Animal
{ public: void letsDo(Operation *v); };

void Dog::letsDo(Operation *v)
{ v->hereIsADog(this); }

class Cat : public Animal
{ public: void letsDo(Operation *v); };

void Cat::letsDo(Operation *v)
{ v->hereIsACat(this); }

Finally, we implement the actual operation, without modifying neither Cat nor Dog:

class Sound : public Operation
{
public:
    void hereIsADog(Dog *d);
    void hereIsACat(Cat *c);
};

void Sound::hereIsADog(Dog *d)
{ std::cout << "woof!\n"; }

void Sound::hereIsACat(Cat *c)
{ std::cout << "meow!\n"; }

Now you have a way to add operations without modifying the hierarchy anymore.
Here is how it works:

int main()
{
    Cat c;
    Sound theSound;
    c.letsDo(&theSound);
}

More Related Contents:

  1. What is the point of accept() method in Visitor pattern?
  2. Difference betwen Visitor pattern & Double Dispatch
  3. Difference between static class and singleton pattern?
  4. On design patterns: When should I use the singleton?
  5. Ways to eliminate switch in code [closed]
  6. What are drawbacks or disadvantages of singleton pattern? [closed]
  7. Are Singletons really that bad? [duplicate]
  8. Design Patterns: Abstract Factory vs Factory Method
  9. When to Use the Decorator Pattern?
  10. What is the facade design pattern?
  11. Design Pattern for Undo Engine
  12. Can’t combine Factory / DI
  13. How to implement the activity stream in a social network
  14. What is the basic difference between the Factory and Abstract Factory Design Patterns? [closed]
  15. When to use the Bridge pattern and how is it different from the Adapter pattern?
  16. How does the Strategy Pattern work? [closed]
  17. How to implement Builder pattern in Kotlin?
  18. What is a Proxy in Doctrine 2?
  19. Cross cutting concern example
  20. Which design patterns can be applied to the configuration settings problem?
  21. What is the Page Object Pattern in Selenium WebDriver? [closed]
  22. What is the difference between Builder Design pattern and Factory Design pattern? [closed]
  23. What is an anti-pattern?
  24. What is the difference between Strategy design pattern and State design pattern?
  25. what is `optimistic updates` in front-end development
  26. REST API Login Pattern
  27. How do you know when to use design patterns? [closed]
  28. Static factory methods vs Instance (normal) constructors?
  29. What would a Log4Net Wrapper class look like?
  30. When do we need decorator pattern?

Leave a Comment