Why is inheritance of a const/non-const function overload ambiguous?

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!

https://stackoverflow.com/questions/5103543/how-does-overloading-of-const-and-non-const-functions-work — Jesper Juhl, Jan 18 '19 at 17:10

user7860670 · Accepted Answer · 2019-01-18T17:13:27.937

19

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; };

edited Jan 18 '19 at 17:13

answered Jan 18 '19 at 17:09

user7860670

35,849
4
58
84

2

An annoying C++ niggle! – Lightness Races in Orbit Jan 18 '19 at 17:12
11

An important C++ protection: if adding a function to a base class changed the overload set your code could quietly break; with this rule it breaks noisily. – Pete Becker Jan 18 '19 at 17:28

score 14 · Answer 2 · answered Jan 18 '19 at 17:13

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.

Why is inheritance of a const/non-const function overload ambiguous?

2 Answers2