Calling proper derived class' method using templates without using virtual? - c++

Question

I have something like the attached. I basically have a Doer class in which I want to call Func() from it's member without using virtual or with the least code duplication possible. Also, boost is not an option either. I know the example may not be so clear but I hope you get the idea. B
class Base { // a bunch of shared base functionality. Cannot be instantiated by itself }
class D1 : public Base
{
void Func();
}
class D2 : public Base
{
void Func();
}
//----
class Doer
{
Doer(Base* b) : base(b) { }
void DoIt()
{
base->Func();
}
Base* base;
}

Answer 1

Well, you can make Doer templated:
template<class T>
class Doer
{
public:
Doer(T* b) : base(b) { }
void DoIt()
{
base->Func();
}
private:
T* base;
};
But for this I would just add a virtual void Func() to Base instead.
Note that you'll probably want to make Func public in either case :-)

Answer 2

What about this approach:
class Base { // a bunch of shared base functionality. Cannot be instantiated by itself
~Base() { //stuff }
void Func();
}
class D1 : public Base
{
void Func();
}
class D2 : public Base
{
void Func();
}
//----
class Doer
{
Doer(Base* b) : base(b) { }
void DoIt()
{
base->Func();
}
Base* base;
}
Since Func() isn't virtual and is being overloaded by the children, there shouldn't be a vtable or any incurred performance penalty right?
Also, the destructor needs to be called on the base class, but declaring it virtual will impose a vtable?
Can anyone clarify?
Thanks

Answer 3

You can use mixins! They're good for optimization (lots of inlining opportunities and no virtual method calls), but sometimes a little hard to reason about. Here's your example implemented with mixins:
template<class Base> class Doer : Base {
public:
Doer() {}
void DoIt() {
this->Func();
}
};
class D1 {
public:
void Func() {
cout<<"Hello from D1"<<endl;
}
};
class D2 {
public:
void Func() {
cout<<"Hello from D2"<<endl;
}
};
Using this is a little different, since the Doer is same as your Base class instance. The following program:
Doer<D1> *d1 = new Doer<D1>();
Doer<D2> *d2 = new Doer<D2>();
d1->DoIt();
d2->DoIt();
Produces the output:
Hello from D1
Hello from D2
This has the obvious drawback that D1 and D2 aren't forced to implement the "Func" method. If you forget it, you'll get an oh-so-handy C++ template instantiation error instead of "method not found." Clang is a great choice if you're going to be using templates frequently, since you get much more helpful compiler errors than with g++. Another drawback is with constructors: Doer defines the default constructor, but doesn't expose D1's constructor. C++11 allows for constructor inheritance, so this issue can be avoided with a compiler flag.

Answer 4

in fact you don't need to parameterize the whole Doer class. This will work just fine (close to what ccurtsinger was suggesting):
class Base {
public:
void Func() {};
};
class B1 {
public:
void Func() { cout << "in B1::Func" << endl;}
};
class B2 {
public:
void Func() { cout << "in B2::Func" << endl;}
};
class Doer {
public:
template <class B> void Do(B *pb) {pb->Func();}
};
int main() {
B1 b1;
B2 b2;
Doer d;
d.Do<B1>(&b1);
d.Do<B2>(&b2);
return 0;
}
But really there's a bigger question: from the code you said you finally used it seems like at compile time you know exactly which derived classes objects you're dealing with, so code like:
for(auto i = begin(B1_container); i != end(B1_container); ++i) {
i->Func();
}
for(auto j = begin(B2_container); j != end(B2_container); ++j) {
j->Func();
}
should do the trick.
What I'm saying is - you either know in advance that you're working with B1-s here and B2-s there and there's no additional cost for Func() invocation, OR you don't know which one you are to deal with next and then you need to check it's dynamic type of some type of trait or whatever and that's an 'if' and thus branching and thus mispredictions and overhead. Notice, I'm not adding the cost of a function call, which is there in both cases regardless.