Compiler differences on choosing the right overload for undefined function

Question

Let's have following code:

//template <typename ... A>
//void foo(char a, A ... args);

template <typename T> void P(T x) { std::cout << x << ' '; }

void foo(char a) { P(3); P(a); }

template <typename ... A>
void foo(int a, A ... args)
{
    foo(args...);
    P(a);
}

template <typename ... A>
void foo(char a, A ... args)
{
    P(a);
    foo(args...);
}

int main()
{
    foo('1', '2', 48, '4', '5');
}

It behaves differently on MSVC2015 and ideone's GCC

When args... equals 48, '4', '5', foo is called. Compilers differs on which foo is called. MSVC takes into account overloads defined bellow actual call (without declaration before) whereas GCC works only with already declared overloads. If I uncomment the declaration, both MSVC and GCC print 1 2 4 3 5 48. If declaration is commented out, MSVC prints the same, but GCC prints 1 2 3 5 52 48 (52 is ascii for 4)

Which compiler is right according to the standard?

I have n4296 draft available, but I've failed to find an answer there, the document is kind of unreadable for me...

It's a well-known problem of MSVC. It doesn't implement two-phase lookup for templates. If you use regular functions rather than templates, there should be no difference. — n. m. could be an AI, Oct 11 '15 at 08:31

score 1 · Accepted Answer · edited May 23 '17 at 12:14

MSVC fails to implement two phase name lookup for templates as prescribed by the standard. This compiler incorrectly defers all name resolution to the point of template instantiation.

Other compilers correctly resolve non-dependent names at the point of template definition. That's the reason for the difference you observe. At the point of definition, the second foo template is invisible so a conforming compiler cannot use it. But at the point of instantiation, it is visible and MSVC happily finds it.

Compiler differences on choosing the right overload for undefined function

1 Answers1