Template function overloading in C++

Question

I have the following definition.

using namespace std;  template <typename T> void foo(const T &s) {     cout << 1; }  template <typename T> void foo(const T *s) {     cout << 2; }  int main(int argc, const char * argv[]) {     char str[] =  "ss";     char *s = str;     foo(s);      return 0; } 

Then it outputs

1 

From my understanding, both versions have to go through a const conversion. Then void foo(const T *s) is more specialized and should be invoked. However the compiler chose void foo(const T& s). What is the explanation?

Answer 1

Some people have pointed out that the parameters of the templates as chosen by the compiler

void f(char * const&) void f(const char *); 

Here, notice that the compiler expects a pointer to char, char*, for the first function and it's a const reference. It may come as a surprise, if you found that for your case it prefers the first template, but for the following two, it will prefer the second

template <typename T> void foo(const T& s) {     cout << 1; }  template <typename T> void foo(T &s) {     cout << 2; } 

So, of course, it will look at the const sometimes. Why didn't it in your case? Because it will only look at the const for a reference if the other function has also a reference.

In your case, from char* to const char* it's a pointer conversion, but from lvalue to const lvalue, it's not actually a conversion. Adding a const by a const reference is ignored by overload resolution except when both functions have reference parameters as in the above case.

Answer 2

The reason is because s is a non-const pointer, so int* const& is actually a better match than int const* because it doesn't have to add const to the pointer type.

If s were const qualified then it would be an exact match for the T const* version.