C++ variadic templates and implicit conversions

Question

I'm trying to figure out how C++ compilers resolve implicit conversions when a variadic template constructor and a conversion operator exist. Here is a minimal example to illustrate:

When I write:

#include <iostream>

class A {
public:
    A () {}

    template<typename...tTypes> A (tTypes...pArgs) {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};

class B {
public:
    operator A () const {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
        return A();
    }
};

int main() {
    B b;
    A a = b;
}

When running I get this output: B::operator A() const. So it is using the conversion operator (as I expected). Live example at http://ideone.com/ZZ2uBz

But when A is a template the outcome is different:

#include <iostream>

template<typename tType>
class A {
public:
    A () {}

    template<typename...tTypes> A (tTypes...pArgs) {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};

class B {
public:
    template<typename tType>
    operator A<tType> () const {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
        return A<tType>();
    }
};

int main() {
    B b;
    A<float> a = b;
}

When running this programm I get this ouput: A<tType>::A(tTypes ...) [with tTypes = {B}; tType = float]. So it is using the variadic constructor of A instead of the conversion operator in B. Live example at http://ideone.com/u9Rxuh

Can someone explain to me why the difference? Shouldn't the conversion operator have precedence over the constructor?

I know I could call the conversion operator explicitly (A<float> a = b.operator A<float>();) but that's not what I want.

Answer 1

It seems to me that the conversion is ambiguous and the other compilers fail as expected (or at least, that was my expectation). See as an example the result of using clang.

To disambiguate it, you can either make the constructor or the conversion operator explicit.
As an example, use this:

template<typename tType>
class A {
public:
    A () {}

    template<typename...tTypes> explicit A (tTypes...pArgs) { /* ... */ }
};

Or this:

class B {
public:
    template<typename tType>
    explicit operator A<tType> () const { return A<tType>(); }
};