Template function overloading with identical signatures, why does this work?

Question

Minimal program:

#include <stdio.h>

#include <type_traits>

template<typename S, typename T>
int foo(typename T::type s) {
    return 1;
}

template<typename S, typename T>
int foo(S s) {
    return 2;
}

int main(int argc, char* argv[]) {
    int x = 3;
    printf("%d\n", foo<int, std::enable_if<true, int>>(x));

    return 0;
}

output:

    1 

Why doesn't this give a compile error? When the template code is generated, wouldn't the functions int foo(typename T::type search) and int foo(S& search) have the same signature?

If you change the template function signatures a little bit, it still works (as I would expect given the example above):

template<typename S, typename T>
void foo(typename T::type s) {
    printf("a\n");
}

template<typename S, typename T>
void foo(S s) {
    printf("b\n");
}

Yet this doesn't and yet the only difference is that one has an int signature and the other is defined by the first template parameter.

template<typename S, typename T>
void foo(typename T::type s) {
    printf("a\n");
}

template<typename S, typename T>
void foo(int s) {
    printf("b\n");
}

Compiler error (Clang):

test.cpp:26:2: error: call to 'foo' is ambiguous
foo<std::enable_if<true, int>>(3);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test.cpp:16:6: note: candidate function [with T = std::__1::enable_if<true, int>]
void foo(typename T::type s) {
        ^
test.cpp:21:6: note: candidate function [with T = std::__1::enable_if<true, int>]
void foo(int s) {
        ^
1 error generated.

I'm using code similar to this for a project I'm working on and I'm afraid that there's a subtly to the language that I'm not understanding that will cause some undefined behavior in certain cases. I should also mention that it does compile on both Clang and in VS11 so I don't think it's just a compiler bug.

---

Edit: Corrected second case (typo); added error message from Clang.

Edit #2: For those of you that asked what T::type means.

From http://en.cppreference.com/w/cpp/types/enable_if:

template< bool B, class T = void > struct enable_if;

If B is true, std::enable_if has a public member typedef type, equal to T; otherwise, there is no member typedef.

enable_if is a struct. Basically, if the expression evaluated in the first template parameter of enable_if is true (and in the case of my examples above, it is), then then there will be a public member type that has the same type as the second template parameter.

In the case of enable_if<true, int>, enable_if::type has a type of int.

Marilou

It's not surprising your last case does not compile. You are using two template arguments when the function(s) only receive one. – Investigator

Thanks, I guess I copied the wrong case there. Fixed. – Marilou

I'm a C++ noob so don't harsh me... Doesn't the first example work because you're overriding the first method? I'm interested to know the answer to this. I plan to learn C++ next year. – Autoxidation

can someone explain what "typename T::type s" means? – Backup

very curious. holler for @Johannes – Mockup

I'll add an edit to the post above. It's a little tricky. – Marilou

Totally bizarre. I can see nothing in the template instantiation rules that would make them any different, and nothing in the overload resolution rules that should cause this to be anything other than ambiguous... – Grimbly

Answer 1

The first function is considered to be more specialized than the first.

The function

int foo(typename T::type)

could match

template <typename S,typename T> int foo(S s)

by using T::type as the value for parameter S, but

int foo(S s)

will not match

template <typename S,typename T> int foo(typename T::type)

because T cannot be deduced.

The logic is layed out in the C++03 standard in section 14.5.5.2, and in the C++11 standard in section 14.5.6.2.

Here is the idea: To see if one function is more specialized than another, you invent values for each template parameter for the first function, and then see if the second function could match the resulting signature. You also invent values for the template parameters of the second function, and see if the first function will match the resulting signature. If the second function can match the first one, then the second function can't be more specialized than the first one. If, in addition to that, the first function can't match the second, then the first must be more specialized than the second. That is the case you have.

Conurbation

Answer 2

Here's an even further simplification of the phenomenon:

#include <stdio.h>

template<typename T>
void foo(int arg) {
    printf("a\n");
}

template<typename T>
void foo(T arg) {
    printf("b\n");
}

int main(int argc, char* argv[]) {
    foo<int>(3);   // prints "a"
    foo(3);        // prints "b"

    return 0;
}

Template parameters can either be passed explictly through angled brackets or they can be resolved through deduction. If a parameter isn't specified explicitly, it must be deducible using the function's arguments.

So, in the case of foo(3), template 'a' won't work, because the parameter T isn't explicitly specified and can't be deduced. In the case of foo<int>(3), both templates could work. In fact, if you comment out template 'a', a call to foo<int>(3) will print "b". So the question is, why is template 'a' prefered? The key here is "partial ordering":

http://publib.boulder.ibm.com/infocenter/lnxpcomp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8l.doc%2Flanguage%2Fref%2Fpartial_ordering_funct_templ.htm

I see now that someone else has already answered (I'm bad at answering questions quickly), so I'm going to just wrap this up now and say that template 'a' is more specialized like Vaughn said.

Trisyllable

Great example -- illustrates how counter-intuitive this can be. – Embank