inherited templated method not visible after method with same name is added - c++

Question

I have the following problem. A class E overrides two methods: one comes from an abstract class D which inherits from a specialization of a templated class C<T> where T = A. The other is from C<A> directly. And both have the same name.
Now, D should have access to both methods: doSomething(const A& a) because it inherits it from C, and doSomething(const B& b) because D declares it.
However, the following code does not compile, because the compiler recognizes only the method doSomething(const B&) from the pointer to D
#include <iostream>
#include <sstream>
using namespace std;
class A {
private:
int a = 10;
public:
inline std::string hello() const{
std::stringstream ss;
ss << a;
return ss.str();
}
};
class B {
private:
int b = 20;
public:
inline std::string hello() const{
std::stringstream ss;
ss << b;
return ss.str();
}
};
template <class T>
class C {
public:
inline virtual bool doSomething(const T& t) {
std::cout << "C is doing something with T" << t.hello() << std::endl;
return true;
}
};
class D : public C<A> {
public:
virtual void doSomething(const B& b) = 0;
};
class E : public D {
public:
inline bool doSomething(const A& a) override {
std::cout << "E is doing something with A: " << a.hello() << std::endl;
return true;
}
inline void doSomething(const B& b) override {
std::cout << "E is doing somethign with B: " << b.hello() << std::endl;
}
};
int main()
{
A a;
B b;
D* d = new E();
d->doSomething(b);
d->doSomething(a); // compile error, does not recognize doSomething(const A&)
delete d;
}
The compiler shows the following error:
In function ‘int main()’:
main.cpp:62:19: error: no matching function for call to ‘D::doSomething(A&)’
d->doSomething(a); // compile error, does not recognize doSomething(const A&)
^
main.cpp:39:18: note: candidate: virtual void D::doSomething(const B&)
virtual void doSomething(const B& b) = 0;
^
main.cpp:39:18: note: no known conversion for argument 1 from ‘A’ to ‘const B&’
Why is that?

Answer 1

This happens because compiler does not automatically merge all the functions from the base classes to the set of overloaded functions to select from. That is the set of overloaded functions considered when you call d->doSomething(a); consists only of D::doSomething(const B& b). In order to fix this you need to bring C<A>::doSomething; into D class
class D : public C<A> {
public:
using C<A>::doSomething;
virtual void doSomething(const B& b) = 0;
};

Answer 2

To make a base class function visible in the derived class which is hidden by a function of the same name, you should use the using directive (using C<A>::doSomething;).
However, I also want to add that GCC 8.2 reports that there is undefined behavior in the code when you delete d. This is because the class D has a non-virtual destructor.
warning: deleting object of abstract class type 'D' which has non-virtual destructor will cause undefined behavior [-Wdelete-non-virtual-dtor]
delete d;
See demo here.