模板类型的隐式转换运算符不会自动确定

Question

I have a templated class thing with an implicit conversion operator, like follows:

#include <stdio.h>

template <typename T>
struct thing
{
    T t;

    operator const T&() const 
    { 
        return t;
    }
};

template <typename T>
struct B 
{
    T t;
};

void fun(const int&) {
    printf("int\n");
}

template <typename T>
void fun(const B<T>&) {
    printf("B<T>\n");
}

int main()
{
    thing<int> a;
    fun(a);

    thing<B<int>> b;
    fun(b);

    return 0;
}

Calling fun(const int&) with a thing<int> , the compiler is able to figure out to invoke the implicit conversion operator in order to pass the const T& (in this case const int& ) to fun(const int&) .

However, for a thing<B<int>> , the compiler can not figure out that I expect fun(const B<T>&) to be invoked.

How can I help the compiler figuring this out without casting b to const B<int>& explicitely (using static_cast<const B<int>&>(b) for instance)?

My concrete usage scenario is similar to the code provided with the constraints that I am using B with ~10 different types T , ie not arbitrary many different T s. If I have to create ~10 template specializations, so be it. However, I don't exactly know how to best overload struct B in that case. But maybe I am on the wrong track - do simpler/more elegant solutions exist, maybe?

Answer 1

How can I help the compiler figuring this out without casting b to const B<int>& ?

You can't. Templates do not do any implicit conversion. They deduce the type of the parameter and that is the type they use.

One thing you can do is add a get function to your wrapper like

template <typename T>
struct thing
{
    T t;

    operator const T&() const 
    { 
        return t;
    }
    const T& get() const 
    { 
        return t; 
    }
};

and then you can call fun like

fun(b.get());

Answer 2

Template argument deduction doesn't consider implicit conversion.

Type deduction does not consider implicit conversions (other than type adjustments listed above): that's the job for overload resolution , which happens later.

Then given fun(b); , the template fun can't be invoked because T can't be deduced.

You can specify the template argument explicitly, then overload resolution and implicit conversion would work fine.

fun<int>(b);

LIVE