stragety of the name lookup about full specialization of function?

Question

Here is two-phase name lookup for template from iso-standard:

• When looking for the declaration of a name used in a template definition, the usual lookup rules (6.4.1, 6.4.2) are used for non-dependent names.

• The lookup of names dependent on the template parameters is postponed until the actual template argument is known

Sample codes:

#include <iostream>

void WithoutTemplate(int) {std::cout << "NonTemplate: int\n";}

template<typename T>
void WithTemplate(T) {std::cout << "no match\n";}

template<>
void WithTemplate(int) {std::cout <<"Template: int\n";}

template<typename T>
void test(T)
{
    WithTemplate(1.1);
    WithoutTemplate(1.1);
}

void WithoutTemplate(double) {std::cout << "nontemplate: double\n";}

template<>
void WithTemplate(double) {std::cout << "template: double\n";}

int main()
{
    test(1.1);
}

output:

template: double NonTemplate: int

There are two functions: WithTemplate and WithoutTemplate. The parameter 1.1 is non-dependent(though it is prvalue, which has no name? I assume it still obey non-dependent name's rules)

• name lookup of WithoutTemplate meets 2-phase lookup, because when calling WithoutTemplate(1.1), void WithoutTemplate(double) is not visible. So the output NonTemplate: int is easy to understand.
• However, the case which invokes full specialization function quite confuses me. its behaviour is opposite to the standard's rules(2-phase lookup). I thought it should output template: int

So, is there other name lookup rules for specialization? Or something else I misunderstand?

Here is what I have read:

• Difference between instantiation and specialization in c++ templates

• Name lookups in C++ templates

Answer 1

Your program has undefined behaviour, because you define the explicit specialization of WithTemplate<double> after it has been implicitly instantiated through the call WithTemplate(1.1). Explicit specializations must appear before any use of them that would cause instantiation - see e.g. http://en.cppreference.com/w/cpp/language/template_specialization.

So there's no point trying to reconcile the behaviour with what the standard says; the standard explicitly says nothing about what should happen here.