What are the rules for choosing from overloaded template functions ?

Question

Given the code below, why is the foo(T*) function selected ?

If I remove it (the foo(T*)) the code still compiles and works correctly, but G++ v4.4.0 (and probably other compilers as well) will generate two foo() functions: one for char[4] and one for char[7].

#include <iostream>
using namespace std;

template< typename T >
void foo( const T& )
{
    cout << "foo(const T&)" << endl;
}

template< typename T >
void foo( T* )
{
    cout << "foo(T*)" << endl;
}

int main()
{
    foo( "bar" );
    foo( "foobar" );
    return 0;
}

Answer 1

Cause " " is a char*, which fits perfectly to foo(T*) function. When you remove this, the compiler will try to make it work with foo(T&), which requires you to pass reference to char array that contains the string.

Compiler can't generate one function that would receive reference to char, as you are passing whole array, so it has to dereference it.

Answer 2

That's because the type of "bar" is indeed char[4], but that easily decays into a char*.

If you want to "catch" instantiations with string literals you would need to add the following overload (note: there's no partial specialization for function templates, there's only overloading):

template< typename T, std::size_t S >
void foo(T(&)[S])
{
  std::cout << "foo(T(&)[S])";
}

This would still cause the compiler to create different instances for "foo" and "foobar" (with different S), but you could easily make this an inline function which forwards to some common implementation.

Answer 3

Based on overload resolution rules (Appendix B of C++ Templates: The Complete Guide has a good overview), string literals (const char []) are closer to T* than T&, because the compiler makes no distinction between char[] and char*, so T* is the closest match (const T* would be an exact match).

In fact, if you could add:

template<typename T>
void foo(const T[] a)

(which you can't), your compiler would tell you that this function is a redefinition of:

template<typename T>
void foo(const T* a)

Answer 4

The full answer is quite technical.

First, string literals have char const[N] type.

Then there is an implicit conversion from char const[N] to char const*.

So both your template function match, one using reference binding, one using the implicit conversion. When they are alone, both your template functions are able to handle the calls, but when they are both present, we have to explain why the second foo (instantiated with T=char const[N]) is a better match than the first (instantiated with T=char). If you look at the overloading rules (as given by litb), the choice between

void foo(char const (&x)[4));

and

void foo(char const* x);

is ambigous (the rules are quite complicated but you can check by writing non template functions with such signatures and see that the compiler complains). In that case, the choice is made to the second one because that one is more specialized (again the rules for this partial ordering are complicated, but in this case it is because you can pass a char const[N] to a char const* but not a char const* to a char const[N] in the same way as void bar(char const*) is more specialized than void bar(char*) because you can pass a char* to a char const* but not vise-versa).