DeMarcus wrote:
Hi,
I have a function template structure like this.
struct A
{
};
struct B : A
{
}
class SomeClass
{
public:
template<typename T>
void fnc( const T& t )
{
std::cout << "Template" << std::endl;
}
void fnc( const A& a )
{
std::cout << "Non-template" << std::endl;
}
};
int main()
{
SomeClass sc;
sc.fnc( A() ); // This gives me "Non-template".
sc.fnc( B() ); // Error! This gives me "Template"
It's not an error. The template, since it's allowed to be
instantiated, participates in the overload resolution. And because
the compiler is able to deduce 'T' as 'B' (most likely), its argument
conversion (reference binding, which is like the "identity") has a
higher rank than the non-template's "derived-to-base" conversion.
That's why the compiler picks the template.
// even though B inherits from A.
Not "even though" but "because".
}
What's the proper way making instances of B access the non-templated
function?
Use SFINAE, make your template function non-instantiatable for any
class that is derived from A. Utilize the 'enable_if' without making
both functions templates. Or invent your own way. For example, use
the fact that any class that derives from A has a member named 'A',
with the same level of access as the base class (public if derived
publicly, etc.)