为什么const / non-const函数的继承过载不明确？

Question

I was trying to create two classes, the first with a non-const implementation of the functions, the second with a const implementation. Here is a small example:

class Base {
protected:
  int some;
};

class A : public virtual Base {
  const int& get() const {
    return some;
  }
};

class B : public virtual Base {
  int& get() {
    return some;
  }
};

class C : public A, B {};

C test;
test.get(); // ambiguous 

The call to the get function is ambiguous. No matter that the const version needs to match more requirements. (Calling get on const C is ambiguous as well, but there is one possible function to call.) Is there a reason for such behaviour in the standard? Thanks!

Answer 1

Ambiguity occurs when compiler tries to figure out to what entity does the name get refer to, prior to overload resolution. It can be a name of function from class A or from class B. In order to build a list of overloads complier needs to select just one of the classes to pull functions from. In order to fix it you can bring that name from both of the base classes into derived class (and make them public):

class C : public A, public B { public: using A::get; public: using B::get; };

Answer 2

The problem is that you don't actually have one unified overload-set, in which the mutable variant would be unambiguously best, but two distinct overload-sets, in A and B , and the compiler will not automatically merge them.

Put

using A::get;
using B::get;

in C to merge the overload-sets and thus resolve the ambiguity.