How to use template parameter to choose method call? - c++

Question

I have a method which is templated and I want it to call a different method depending on the template. The reason I have this is so that the caller does not need to create an Object of type B just to get the correct implementation called, instead they should be able to just choose by the implementation by templating.
The problem is i'm receiving reference type to a const as the template T and I do not know how to use this to choose the correct overloaded method. Ideally this would also work if T were not a reference type. Any idea?
Note: I can't use template specialization because I need the impl virtual.
#include <iostream>
using namespace std;
class A {};
class B {};
class C {
public:
template <typename T>
void f() {
// T = const B&
impl(T()); // error: value-initialization of reference type ‘const B&’
}
protected:
virtual void impl(const A& a) {
cout << "A";
}
virtual void impl(const B& b) {
cout << "B";
}
};
int main() {
C c;
const B &b2 = B();
c.f<decltype(b2)>(); // T = const B&
return 0;
}

Answer 1

If you want to get a type [more] likely to be constructible, you should remove any references, e.g., using std::remove_reference<T> and all qualifiers, e.g., using std::remove_cv<T>. ... or, just std::decay<T> the type which also transforms arrays into pointers:
template <typename T>
void f() {
impl(typename std::decay<T>::type());
}

Answer 2

You can still use template specialization through a helper private template dispatcher to call correct version of impl - which can still be virtual. Like this, compiles and runs
#include <iostream>
using namespace std;
class A {};
class B {};
class C {
public:
template <typename T>
void f() {
// T = const B&
impl_dispatch<T>(); // error: value-initialization of reference type ‘const B&’
}
protected:
virtual void impl(const A& a) {
cout << "A";
}
virtual void impl(const B& b) {
cout << "B";
}
private:
template <typename T>
void impl_dispatch();
};
template <> void C::impl_dispatch<A const &>()
{
impl(B());
}
template <> void C::impl_dispatch<B const &>()
{
impl(A());
}
int main() {
C c;
const B &b2 = B();
c.f<decltype(b2)>(); // T = const B&
return 0;
}