Question

Let’s say I have the following code:

struct Z;

struct A
{
  virtual void Do (Z & z) const;
};

struct B : public A {};

struct Z
{
  void use (A const & a) {}
  void use (B const & b) {}
};


void A::Do(Z& z) const{
  z.use(*this);
}

Right now, when I call B.do, the type of this is A, which make sense, because the implementation of do is defined in A.

Is there any way to have calls to B.do use use (B const &) without having to copy-paste the same code for do from A into B? In my actual code I have about 15 (and growing) classes derived from some base class and it seems a waste having to copy-paste the identical code for do everytime.

[Edit] Clarification: all Do does is call use, nothing else. Do and use are the accept & visit functions from the Visitor pattern.

Answer 1

Since you now clarified that what you want is the visitor pattern, well, sorry, but that’s just how it is. This answer shows how the visitor pattern with double dispatch works.

---

I thought of a nice way using CRTP, but this may or may not work for you, depending on the circumstances.
^{(Note: I used the code from the linked answer, so the names don’t match, but I hope you get the idea.)}

// your Z
class Visitor;

// superclass needed for generic handling
struct Superbase{
  virtual void Accept(Visitor& v) = 0;
};

// your A
template<class Der>
class Base : public Superbase{
public:
    void Accept(Visitor& v){
        v.Visit(static_cast<Der&>(*this));
    }
};

// your B
class Derived1 : public Base<Derived1> {
};

// new C
class Derived2 : public Base<Derived1> {
};

class Visitor {
public:
    virtual void Visit(Superbase& sup){
      // generic handling of any Superbase-derived type
    }

    virtual void Visit(Derived1& d1){
      // handle Derived1
    }

    virtual void Visit(Derived2& d2){
      // handle Derived1
    }
};

int main(){
    Visitor v;
    Derived1 d1;
    d1.Accept(v);
}

The only problem: Now you’re missing the chance to have a generic handle to any type of A, since functions can’t be both virtual and templates. 😐
Scrape that, found a solution using a Superbase base class. 🙂 This even allows you to have a container of Superbases and take full advantage of polymorphism. 🙂