C++ 未自动确定模板化类型的隐式转换运算符

我有一个带有隐式转换运算符的模板类

thing

，如下所示：

#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;
}

#包括
模板
结构物
{
T；
运算符常量T&（）常量
{ 
返回t；
}
};
模板
结构B
{
T；
};
虚无乐趣（常数整数&）{
printf（“int\n”）；
}
模板
无效乐趣（常数B&）{
printf（“B\n”）；
}
int main（）
{
一件事；
乐趣（a）；
事情b；
乐趣（b）；
返回0；
}

使用

东西调用
fun（const int&
），编译器能够找到调用隐式转换运算符的方法，以便将
常量T&
（在本例中为
const int&
）传递给
fun（const int&
）

然而，对于一个
东西
，编译器不能理解我期望调用
fun（const B&）

我如何帮助编译器明确地（例如使用
static\u cast（b）
）将
b
转换为
const b&
，而不将转换为
b

我的具体使用场景与我使用的约束条件下提供的代码类似，约束条件包括约10种不同类型的
T
，即没有任意多个不同的
T
s。如果我必须创建10个模板专门化，那就这样吧。然而，在这种情况下，我不知道如何最好地重载
structb
。但也许我走错了方向——也许存在更简单/更优雅的解决方案吗

如何帮助编译器在不将
b
转换为
const b&
的情况下解决这个问题

你不能。模板不进行任何隐式转换。他们推断出参数的类型，也就是他们使用的类型

您可以做的一件事是向包装器添加一个get函数，如

template <typename T>
struct thing
{
    T t;

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

不考虑隐式转换。
类型演绎不考虑隐式转换（除了上面列出的类型调整）：这是以后发生的工作。
然后给出
fun（b）
，无法调用模板
fun
，因为无法推断
t

您可以显式指定模板参数，然后重载解析和隐式转换就可以了

fun<int>(b);

fun（b）；

基本上不能，模板不是这样工作的。他们不做转换。所以，我不能部分专注于
B
或类似的东西？但是我可以创建10个重载到
fun（）
，对吗？@j00hi您不能部分地专门化函数。您可以添加10个具体的函数重载。
fun<int>(b);