Virtual Method calling another virtual method in a templatized class

Question

I've been reading different questions on this topic, but haven't been able to find one that quite answers what I'm looking for. Here's the pattern of code that I have:

class Base {
public:
    virtual void foo(int) const {...}
}

template <class T>
class TmplClass : public Base {
public:
    virtual void foo(int i) const { foo(T(i)); }
    virtual void foo(T& param) const {
        printf("Template::Foo\n");
        bar(param);
    }
    virtual void bar(T&) const {
        printf("Template::Bar\n");
    }
}

class Derived : public TmplClass<SomeConcreteType> {
public:
    void bar(SomeConcreteType&) {
        printf("Derived::Bar\n");
    }
}

int main() {
    Derived d;
    Base* b = &d;
    b->foo(1);
}

On execution I get:

Template::Foo
Template::Bar

Why doesn't the run-time dispatch on the call to bar work? If I overload foo in Derived then it does call the derived version of foo, why can't it do the dynamic dispatch for bar?

Because I'm working in existing code, I would prefer not to change the basic structure of the classes here. I'm hoping to just find a way to make the call work, or understand why it doesn't. I've tried lots of different things based on reading other questions here, but all to no avail.

This doesn't look like a working example. `void foo(void)` method doesn't exist, `Base` is not the ancestor class of anything. Please provide working code. — Jack, Dec 11 '13 at 01:32
It doesn't work because this code does not compile. [This similar program](http://coliru.stacked-crooked.com/a/f97076ef0ad89f1f) compiles and runs ok, though. — Casey, Dec 11 '13 at 02:02
Sorry, the TmplClass was missing the ": public Base". And, turns out the template issue was a red herring. In the actual code, my Derived::Bar definition was not marked const where-as the TmplClass::Bar was, so I wasn't actually overriding the method. — Daniel Skarbek, Dec 11 '13 at 17:38

Daniel Skarbek · Accepted Answer · 2013-12-11T17:50:42.237

Turns out this wasn't a template issue. The problem with the code is that the Derived::bar method is not marked as const where-as the TmplClass::bar method is marked const. So, the intention was to provide an over-ride, but actually Derived::bar is a totally different method with a different signature, so that's why it was giving un-expected behavior. Once the const is removed from TmplClass::bar or added to the Derived::bar then the signatures match and the expected output is received:

Template::Foo
Derived::Bar

Virtual Method calling another virtual method in a templatized class

1 Answers1