Multiple inheritance/overloading ambiguity - is this behaviour intentional?

[Adam Nielsen]

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?

Thanks,
Adam.

 

[Victor Bazarov]

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>
{

Just add

using Parent<A>::doit;
using Parent<B>::doit;

here and everything compiles.

};

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?

See above.

V

 

[dasjotre]

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>
{

public:
using Parent<A>::doit;

 

[Adam Nielsen]

Just add

using Parent<A>::doit;
> using Parent<B>::doit;

here and everything compiles.

Ah, I knew there'd be an easier way, thanks for that. Unfortunately it
won't be the tidiest solution for my problem - if each class inherits a
bunch of functions, that could be quite a lot of "using" statements.

I've come up with somewhat of a hack to get around it, in the form of a
new class that will only be inherited once:

template <class TMain>
class ParentHandler
{
public:
template <class TParent>
void doit2(const TParent& param)
{
TMain *p = static_cast<TMain *>(this);
return p->Parent<TParent>::doit(param);
}
};

It can then be used like this:

class Child: public Parent<A>, public Parent<B>,
public ParentHandler<Child>
{
};

And then it removes the ambiguity when used, regardless of how many
Parent classes are inherited (and no code changes are required when
adding more inherited objects):

c.doit2(a); // call Parent<A>.doit()
c.doit2(b); // call Parent<B>.doit()

Granted it's somewhat ugly, but my emphasis here is to make my class
easy to use, not necessarily easy to write

Cheers,
Adam.