Why no ambiguity in this function call?

Question

I'm wondering why there's no ambiguity in this function call:

#include <iostream>
#include <vector>

template <class T>
class C
{
public:
    typedef char c;
    typedef double d;

    int fun() {}

    static c testFun( decltype(&C::fun) ) {return c();} 
    static d testFun(...) { return d(); }
};

int main() {
    C<int>::testFun(0); // Why no ambiguity?
}

http://coliru.stacked-crooked.com/a/241ce5ab82b4a018

Answer 1

There's a ranking of implicit conversion sequences, as defined in [over.ics.rank], emphasis mine:

When comparing the basic forms of implicit conversion sequences...
- a standard conversion sequence (13.3.3.1.1) is a better conversion sequence than a user-defined conversion sequence or an ellipsis conversion sequence, and
- a user-defined conversion sequence (13.3.3.1.2) is a better conversion sequence than an ellipsis conversion sequence (13.3.3.1.3).

So we have two functions:

static char   testFun( int (C::*)() ) { return char(); }
static double testFun( ... ) { return double(); }

Both functions are viable for testFun(0). The first would involve a "null member pointer conversion" as per [conv.mem], and is a standard conversion sequence. The second would match the ellipsis and be an ellipsis conversion sequence. By [over.ics.rank], the former is preferred. There's no ambiguity, the one is strictly better than the other.

An ambiguous overload would arise if we had two equivalent conversion sequences that the compiler could not decide between. Consider if we had something like:

static char testFun(int* ) { return 0; }
static int testFun(char* ) { return 0; }

testFun(0);

Now both overloads would be equivalent as far as the conversion sequences go, so we'd have two viable candidates.