This can be done in C++11 using variadic templates. Continuing from Pete’s answer: // Visitor template declaration template<typename… Types> class Visitor; // specialization for single type template<typename T> class Visitor<T> { public: virtual void visit(T & visitable) = 0; }; // specialization for multiple types template<typename T, typename… Types> class Visitor<T, Types…> : public Visitor<Types…> … Read more
In short they come from to different conceptualizations that, in some languages where double dispatch is not natively supported, lead to the visitor pattern as a way to concatenate two (or more) single dispatch in order to have a multi-dispatch surrogate. In long The idea of multiple dispatch is – essentially – allow a call … Read more
Visitor pattern is used to implement double dispatch. In plain words it means that the code that gets executed depends on runtime types of two objects. When you call a regular virtual function, it is a single dispatch: the piece of code that gets executed depends on the runtime type of a single object, namely, … Read more
The visitor pattern’s visit/accept constructs are a necessary evil due to C-like languages’ (C#, Java, etc.) semantics. The goal of the visitor pattern is to use double-dispatch to route your call as you’d expect from reading the code. Normally when the visitor pattern is used, an object hierarchy is involved where all the nodes are … Read more
With std::common_type, this is straightforward: template <class… Args, class = std::common_type_t<Args…>> void foo(Args &&… args) { } This will only be guaranteed to be SFINAE-friendly from C++17 onwards, though. Clang and GCC both implement it that way already.
So you’ve probably read a bajillion different explanations of the visitor pattern, and you’re probably still saying “but when would you use it!” Traditionally, visitors are used to implement type-testing without sacrificing type-safety, so long as your types are well-defined up front and known in advance. Let’s say we have a few classes as follows: … Read more
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 … Read more