Question

I’d like to specify a conversion from A<T>::B to A<U>::B.

template<typename T>
struct A
{
    struct B
    {
        B() {}

        template<typename U>
        B(const typename A<U>::B& rhs) {}
    };
};

int main()
{
    A<int>::B x;
    A<double>::B y = x;
}

I thought this would do it, but I get the compiler error:

conversion from ‘A<int>::B’ to non-scalar type ‘A<double>::B’ requested”

Why isn’t my code correct, and what’s the correct way to achieve the desired conversion?

Answer 1

Slightly amended source, to demonstrate that this is about the limits to the type deduction system:

template<typename T>
struct A
{
    struct B
    {
        B() {}

        template<typename U>
            B(const typename A<U>::B& rhs) {}

        template<typename U>
            B& operator=(const typename A<U>::B& rhs) {}

        template<typename U>
            B& something(const typename A<U>::B& rhs) {}
    };
};

int main()
{
    A<int>::B x;

    A<double>::B y(x);     // fails to deduce
    A<double>::B y = x;    // fails to deduce
    A<double>::B y; y = x; // fails to deduce

    x.something(y);        // fails to deduce
    x.something<double>(y);// NO PROBLEM
}

You see that when we help the compiler a little, there is no more problem. Also note the actual compiler error (gcc) shows it’s confusion:

test.cpp|24 col 15| note: candidate is:
test.cpp|15 col 44| note: template<class U> A<T>::B& A<T>::B::something(const typename A<U>::B&) 
 [with U = U, T = int, A<T>::B = A<int>::B, typename A<U>::B = A<T>::B]

Notice the part where U = U (i.e. unresolved)