base class pointer, invoke method based on derived type

Question

I understand that the following code doesn't work -- can't convert base to foo.

Is there something I can do, or some pattern to employ which would get me close the behavior I'm trying to achieve in the code below? IOW, if I have a base class pointer to a derived type, how can I invoke a specific method that matches the derived type (not the base type)?

What patterns might I use? I looked into Curiously Recursive (or recurring) Template Pattern, however this imposed other limitations itself.

class base {};
class foo : public base {};
void method(const foo& f){}
int main(){
  base* b = new foo();
  method(*b);
}

Answer 1

The easiest way is probably to just make method() a virtual member function on foo:

class base { 
 public:
  virtual void method() const = 0;
};
class foo : public base {
 public:
  void method() const override { }
};

int main(){
  foo f;
  base* b = &f;
  b->method();
}

But if for some reason that is not possible (perhaps you don't have access to method() or perhaps you want to keep the logic in method() separate from foo) you could use a simplified version of the Visitor Pattern.

The visitor pattern relies on all the classes in your hierarchy having a virtual function to dispatch based on class type.

In your case you don't need double-dispatch so you don't actually need the visitor object and can just call your method function directly from a virtual dispatch function:

class base { 
 public:
  virtual void dispatch() const = 0;
};
class foo : public base {
 public:
  void dispatch() const override;
};

void method(const foo& f){}

void foo::dispatch() const {
  method(*this);
}

int main(){
  foo f;
  base* b = &f;
  b->dispatch();
}

You have to remember that in most contexts the compiler doesn't know that your base pointer is actually of type foo.

Answer 2

Use virtual functions to solve these kinds of problems:

class base {
  public:
    virtual void func() const { /* A */ }
};
class foo : public base {
  public:
    void func() const override { /* B */ }
};
void method(const base& f) {
    f.func();
}
int main(){
  base* b = new foo();
  method(*b);
}

Now, depending on the actual type of f, either A or B code will be executed in method.