How to resolve multiple inheritance ambiguities in C++

Question

I have a small program as follows:

#include <iostream>

template <typename T>
class X{
    public:
        bool something(){
            return true;
        }
};

class A: public X<A>{
};


class B: public A, public X<B>{
};


template <typename T>
bool use(T &t)
{
    return t.something();
}



int main()
{
    B b;
    std::cout << "use returned: " << use(b);
}

This will not compile because there is an ambiguity as to which of the two possible versions of something() should be selected:

In instantiation of 'bool use(T&) [with T = B]':
30:43:   required from here
22:20: error: request for member 'something' is ambiguous
6:14: note: candidates are: bool X<T>::something() [with T = B]
6:14: note:                 bool X<T>::something() [with T = A]
 In function 'bool use(T&) [with T = B]':
23:1: warning: control reaches end of non-void function [-Wreturn-type]

My question is, how can I resolve this ambiguity if the only place I can edit is the body of use()?

You could cast it to a X<T> or an A object. For example ((A)t).something() — Jake Freeman
– Jake Freeman, Commented Dec 10, 2017 at 3:19
I am a little unsure how that cast would look like. Just good old (mytype)? — Mr. Developerdude
– Mr. Developerdude, Commented Dec 10, 2017 at 3:23
Yes ((sometype)t).something() make sure you have the right () for order of operators. — Jake Freeman
– Jake Freeman, Commented Dec 10, 2017 at 3:26
Also let me know if this does not work (I tested it and it did) I have some other suggestions you could try. — Jake Freeman
– Jake Freeman, Commented Dec 10, 2017 at 3:37

vitaut · Accepted Answer · 2017-12-10 03:45:26Z

4

Yes. For example, you can qualify the call to something (godbolt):

template <typename T>
bool use(T &t)
{
    return t.A::something();
}

answered Dec 10, 2017 at 3:45

vitaut

57.4k31 gold badges232 silver badges409 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

bpeikes · Accepted Answer · 2017-12-18 03:28:05Z

1

You could add a specialization of the template “use” for the case where T derives from X and then casts to X inside.

template <typename T>
class X{
    public:
        bool something(){
            return true;
        }
};

class A: public X<A>{
};


class B: public A, public X<B>{
};

#
# If class derives from X<T> make sure to cast to X<T> before calling something
#
template<typename T>
typename std::enable_if<std::is_base_of<X<T>, T>::value, bool>::type use(T &t)
{
     return static_cast<X<T>&>(t).something();
}

#
# This gets run for everything that doesn't derive from X<T>
#
template<typename T>
typename std::enable_if<!std::is_base_of<X<T>, T>::value, bool>::type use(T &t)
{
     return t.something();
}

Have to check the syntax though, but this should make sure you get it for your special case while allowing anything with only one “something” call.

edited Dec 18, 2017 at 3:28

answered Dec 12, 2017 at 2:37

bpeikes

3,73912 gold badges48 silver badges93 bronze badges

1 Comment

bpeikes Over a year ago

Updated code above to compile. Note that this allows you add specializations for any case where T is derived from multiple classes that have a "something" method. You would just add another template that specializes and casts.

Collectives™ on Stack Overflow

How to resolve multiple inheritance ambiguities in C++

2 Answers 2

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related