模板化运算符实例化和类型转换

Question

如果是 C++ 大师的话。

考虑以下代码：

class X { };

template <class T>
class Mistake {
public:
  T x;

  Mistake(const T& k) : x(k) { }
  Mistake(const X&) : x(1) { }

  void print() { cout << x << endl; }
};

template <class T>
Mistake<T> operator+(const Mistake<T>& a, const Mistake<T>& b)
{
  return Mistake<T>(a.x + b.x);
}

我有一个类“错误”，我想对其进行加法运算。当我尝试时：

X a, b;
Mistake<int> foo = a + b;

我得到一个编译错误；编译器似乎无法意识到模板 operator+ 必须被实例化。

另一方面，如果我在之前添加以下代码：

Mistake<int> operator+(const Mistake<int>& a, const Mistake<int>& b)
{
  return Mistake<int>(a.x + b.x);
}

那么一切都很好。有人知道为什么吗？我怀疑编译器无法确定要实例化什么，因为需要从类 X 到类 Mistake 的类型转换，但我不知道如何解决这个问题，除非根本不使用模板。

顺便说一句，将类中的操作符定义为友元也行不通。

谢谢！

Answer 1

虽然其他人已经为您的问题提出了可能的解决方案，但我想指出发生了什么，以及为什么无法满足您的期望。

这里的问题是执行类型推导时没有考虑用户定义的转换。当编译器出现这个表达式时：

a + b

a 和 b 的类型均为 X，operator + 的签名如下：

template <class T>
Mistake<T> operator+(const Mistake<T>& a, const Mistake<T>& b)

编译器要做的第一件事是尝试推导T，以便运算符的参数类型与参数类型exaclty相匹配。如果这不可能，编译器立即放弃，不考虑可能的转换构造函数，并专注于其他候选函数（或函数模板）。

考虑到上面的情况，很明显没有办法让Mistake<T>变成exaclty X，无论你选择什么T（Mistake<int>不是X， Mistake<X> 不是 X，以此类推）。因此，替换失败，编译器不知道如何解决调用，因为周围没有其他候选者。

另一方面，当你有这个时：

Mistake<int> operator+(const Mistake<int>& a, const Mistake<int>& b)

不涉及类型推导，因为上面不是函数模板。因此，编译器在尝试解析调用时将考虑用户定义的转换，并且由于Mistake<int> 有一个接受X 的构造函数，因此上述operator + 被认为是可行的候选人，并被选中。

Answer 2

我认为没有办法。你能做到的最纯粹的是

Mistake<int> foo = static_cast<Mistake<int>>(a) + static_cast<Mistake<int>>(b);

或者，如果您使用匹配非对称操作数类型的附加重载稍微推动它：

template <class T, class U>
Mistake<T> operator+(const Mistake<T>& a, U const& b) {
    return a + static_cast<Mistake<T>>(b);
}

    // and later:
    foo = Mistake<int>(a) + b;

完整的现场演示：http://ideone.com/ki14GO

#include <iostream>

class X { };

template <class T>
class Mistake {
    public:
        T x;

        Mistake(const T& k) : x(k) { }
        Mistake(const X&) : x(1) { }

        void print() { std::cout << x << std::endl; }
};

template <class T>
Mistake<T> operator+(const Mistake<T>& a, const Mistake<T>& b) {
    return Mistake<T>(a.x + b.x);
}

template <class T, class U>
Mistake<T> operator+(const Mistake<T>& a, U const& b) {
    return a + static_cast<Mistake<T>>(b);
}

template <class T, class U>
Mistake<T> operator+(const U& a, Mistake<T> const& b) {
    return static_cast<Mistake<T>>(a) + b;
}

int main()
{
    X a, b;
    Mistake<int> foo = static_cast<Mistake<int>>(a) + static_cast<Mistake<int>>(b);
    foo = Mistake<int>(a) + b;
    foo = a + Mistake<int>(b);
}

Answer 3

我认为编译器在推断a + b 的类型时有问题。

你可以定义：

X operator+(const X & a, const  X & b) {
   return a /* ??? or something else */;
}

如果您有任何方法可以判断a + b 的答案是什么X。