Question

I have the following code:

#include <iostream>
#include <vector>
using namespace std;

struct A{};
struct B: public A {};

template <typename T>
void foo(const T& obj) { cerr << "Generic case"<< endl;}

void foo(const A& a) {
    cerr << "Specific case" << endl;
}

int main() {
    vector<int> v;
    foo(v);
    B b;
    foo(b);
    A a;
    foo(a);
}

Output is

• Generic case
• Generic case
• Specific case

Why is it that foo(const A& a) is not being chosen for the B object ?

Curiously enough, if I removed the templated method and just have the following:

#include <iostream>
#include <vector>

struct A{};
struct B: public A {};

//template <typename T>
//void foo(const T& obj) { cerr << "Generic case"<< endl;}

void foo(const A& a) {
    cerr << "Specific case" << endl;
}

int main() {
    B b;
    foo(b);
    A a;
    foo(a);
}

The code compiles and the output is:

Specific case
Specific case

Why is the presence of the templated method making such a difference?

Edit: How can I force the compiler to choose the free method for classes derived from A in the presence
of the templated method?

Answer 1

No conversion is necessary for the call to foo(const B&) which the template instantiation yields thus it is the better match.

When a function call is seen by the compiler, every base function template has to be instantiated and is included in the overload set along with every normal function. After that overload resolution is performed. There is also SFINAE, which allows an instantiation of a function template to lead to an error (such a function would not be added to the overload set). Of course, things aren’t really that simple, but it should give the general picture.

Regarding your edit: There is only one method to call. What else could there be as output?