Resolving overloading ambiguity with multiple inheritance of base class templates in C++ - c++

Question

Let's say I'm trying to create a Combine class that will be derived from the given base classes.
template<typename ...Bases>
class Combine : public Bases... {};
And this works fine. For example, if I have class Foo and class Bar then class Combine<Foo, Bar> will implement all the methods from Foo and Bar. At least I thought so until I tried this:
struct ContainerProvider {
std::vector<int> container{1, 2, 3};
};
struct ConstGetter : public virtual ContainerProvider {
[[nodiscard]] const int &get(int index) const {
return container[index];
}
};
struct MutableGetter : public virtual ContainerProvider {
int &get(int index) {
return container[index];
}
};
template<typename ...Bases>
class Combine : public Bases... {};
int main() {
Combine<ConstGetter, MutableGetter> container;
container.get(1); // Member 'get' found in multiple base classes of different types
}
In normal situations, I would just use using Super::method;, but here I don't know the names of derived methods. In a perfect world, I could use something like this:
template<typename ...Bases>
class Combine : public Bases... {
using Bases::* ...;
};
But C++ does not allow this.
Is it possible to implement my Combine class somehow? I'm pretty sure the compiler can get all the information to resolve this edge case, but I have no idea how to provide it to make it work.

Answer 1

Curious problem since get() defined only in one class would work perfectly, but in two? Error? I was curious if there might be a core language defect since this problem seems solvable by the compiler, but I didn't see any (http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html).
The ideal solution would probably be for MutableGetter to inherit from ConstGetter since, logically, a getter that allows mutation should also allow grabbing non-mutable versions.
struct MutableGetter : public ConstGetter {
using ConstGetter::get;
int &get(int index) {
return container[index];
}
};
Here's the closest I could get:
#include <iostream>
#include <vector>
struct ContainerProvider {
std::vector<int> container{1, 2, 3};
};
struct ConstGetter : public virtual ContainerProvider {
[[nodiscard]] const int &get(int index) const {
std::cout << "CONST" << std::endl;
return container[index];
}
};
struct MutableGetter : public virtual ContainerProvider {
int &get(int index) {
std::cout << "NON-CONST" << std::endl;
return container[index];
}
};
template <typename... Bases>
class Combine;
template <typename B1, typename B2, typename... Bases>
struct Combine<B1, B2, Bases...> : public B1, public Combine<B2, Bases...> {
using B1::get;
using Combine<B2, Bases...>::get;
};
template<typename B>
struct Combine<B> : B {
using B::get;
};
int main() {
Combine<ConstGetter, MutableGetter> container;
std::cout << container.get(0) << std::endl; // non-const
const auto &const_container = container;
std::cout << const_container.get(0) << std::endl; // const
}
It really sucks for the Combine to have to know what member functions its parents expose, though. I found one partial solution if you're willing to drop the idea of member functions and occasionally do a cast...: Use friend functions
#include <iostream>
#include <vector>
struct ContainerProvider {
std::vector<int> container{1, 2, 3};
};
class ConstGetter : public virtual ContainerProvider {
[[nodiscard]] const int &get(int index) const {
std::cout << "CONST" << std::endl;
return container[index];
}
friend [[nodiscard]] const int& get(const ConstGetter &self, int i) { return self.get(i); }
};
class MutableGetter : public virtual ContainerProvider {
int &get(int index) {
std::cout << "NON-CONST" << std::endl;
return container[index];
}
friend [[nodiscard]] const int &get(MutableGetter &self, int i) {
return self.get(i);
}
};
template <typename... Bases>
class Combine : public Bases... {};
int main() {
Combine<ConstGetter, MutableGetter> container;
std::cout << get((MutableGetter&)container, 0) << std::endl;
const auto &const_container = container;
std::cout << get(const_container, 0) << std::endl;
}

Answer 2

I imagine that renaming ConstGetter::get() to ConstGetter::const_get is not an option? However, this compiles: container.ConstGetter::get(); container.MutableGetter::get();, check it here
As of why overload resolution doesn't work across classes, you could check
this old post
and the answer of this question.