模板类的二元运算符不解决隐式转换

Question

考虑以下类，其中第一个是模板化的。两者都用于保存数值。

template<typename T>
struct foo
{
    foo(T val) : val{ val } {}
    T val;
};

struct bar
{
    bar(double val) : val{ val } {}
    double val;
};

我想定义一种方法将这些类添加在一起以获得具有不同值的新类。

template<typename T>
foo<T> operator+(foo<T> a, foo<T> b)
{
    return foo<T>(a.val + b.val);
}

bar operator+(bar a, bar b)
{
    return bar(a.val + b.val);
}

当我将这些运算符与隐式转换一起使用时，使用 foo 类型对象的运算符不会对双精度值使用隐式转换来应用我的重载运算符，即使它可以为非模板类​​执行此操作.结果是没有与该表达式中的类型匹配的运算符。

int main()
{
    foo<double> foo_value(11.0);
    bar bar_value(11.0);

    foo<double> ev1 = foo_value + 1.0; // no operator matches these operands
    bar ev2 = bar_value + 1.0;
}

操作符必须先显式实例化吗？如果是这样，a) 看起来如何，以及 b) 如果可以在初始化 foo<double> 类型的对象时完成实例化，为什么不隐式完成？

如果标准不支持任何类型的解析而不明确地将1.0 转换为foo<double> 类型的值，我认为唯一的另一种可能性是为我想要使用的每种类型定义运算符重载（对于左右两边）？

Answer 1

关于模板，您必须记住的是，它们不会为您进行转换。他们所做的只是尝试找出事物的类型，如果这与模板参数相匹配，那么它将删除该函数并调用它。

当你这样做时

foo_value + 1.0

编译器没问题，让我们看看我们是否有任何operator + 可以解决这个问题。它发现

template<typename T>
foo<T> operator+(foo<T> a, foo<T> b)
{
    return foo<T>(a.val + b.val);
}

然后它会尝试找出T 是什么，这样它就可以删除一个具体的函数。它查看foo_value，发现它是foo<double>，所以它说第一个参数T 需要是double。然后它查看1.0 并没问题，我有一个double，那就是你遇到问题的时候。编译器无法推断出T 应该是什么b，因为它需要一个foo<some_type>，但是却得到了一个double。因为不能推导出类型，所以你的代码编译失败。

为了获得你想要的行为，你需要添加

template<typename T>
foo<T> operator+(foo<T> a, T b)
{
    return foo<T>(a.val + b);
}

这可以让您将T 添加到foo<T>，或者更好

template<typename T, typename U>
foo<T> operator+(foo<T> a, U b)
{
    return foo<T>(a.val + b);
}

这可以让您向foo<T> 添加任何内容（例如foo<double> + int，第一个版本不允许这样做）