Hi everyone,
I've run into yet another quirk with templates, which IMHO is a
somewhat limiting feature of the language.
It seems that if you inherit multiple classes, and those classes have
two functions with the same name, this is an error - even when the
functions take different parameters, and they would happily exist as
overloaded functions if they were declared in the same class instead
of being inherited.
For example, this code won't compile:
class A { };
class B { };
template <typename T>
class Parent
{
public:
void doit(const T& t)
{
// do stuff with t
}
};
class Child: public Parent<A>, public Parent<B>
{
};
int main(void)
{
A a;
B b;
Child c;
c.doit(a); // call Parent<A>.doit()
c.doit(b); // call Parent<B>.doit()
return 0;
}
My understanding is that the compiler must find a unique name *before*
it looks at overloading, which means the above code fails because
doit() exists twice, even though each version takes a different
parameter type.
I'm surprised this seems to be the intended behaviour (I thought it
was a bug in my compiler.) I can't think of any reason where this
would be desired behaviour!
I've come up with a workaround, which involves implementing a single
function in class Child which resolves the ambiguity:
class Child: public Parent<A>, public Parent<B>
{
public:
template <class T>
void doit2(const T& t)
{
this->Parent<T>::doit(t);
}
};
This fixes the problem, and avoids the need to manually specify the
type in main() where the users of my class aren't supposed to know
about the type (not to mention the typename it's very long and makes
the code look messy.)
Is this a correct way of dealing with this issue? Are there any
better ways?