2

以下是我从另一个问题中获取的示例，我理解为什么这不起作用：

struct Foo {
    Foo() {}
    Foo(int) {}
    Foo operator+(Foo const & R) { return Foo(); }
};


struct Bar {
    Bar() {}
    Bar(int) {}
};

Bar operator+(Bar const & L, Bar const & R) {
    return Bar();
}


int main() {
    Foo f;
    f+1;  // Will work - the int converts to Foo
    1+f;  // Won't work - no matching operator
    Bar b;
    b+1;  // Will work - the int converts to Bar
    1+b;  // Will work, the int converts to a Bar for use in operator+

}

但是，如果我将其更改为以这种方式使用模板：

template <class T>
struct Foo {
    Foo() {}
    Foo(T) {}
    Foo operator+(Foo const & R) { return Foo(); }
};


template <class T>
struct Bar {
    Bar() {}
    Bar(T) {}
};

template <class T>
Bar operator+(Bar const & L, Bar const & R) {
    return Bar();
}


int main() {
    Foo<int> f;
    f+1;  // Will work - the int converts to Foo
    1+f;  // Won't work - no matching operator
    Bar<int> b;
    b+1;  // DOES NOT WORK
    1+b;  // DOES NOT WORK

}

这没用。任何人都可以对此有所了解吗？模板快把我逼疯了。

谢谢。

4

2 回答 2

3

有两个问题。

  1. 您需要将模板类型添加到运算符定义中的参数中。这是必要的，因为它需要使用它们来知道要使用哪个 Bar 实例化。
  2. 如果您想在模板函数中使用混合运算符（对两种不同类型进行操作），则需要为所有混合情况提供定义。否则，模板扣除系统将无法按您希望的方式运行。

.

template <class T>
Bar<T> operator+(Bar<T> const & L, Bar<T> const & R) { // Fixed
    return Bar<T>();
}

template <class T>
Bar<T> operator+(Bar<T> const & L, const T & R) { // Added
    return L + Bar<T>(R);
}


template <class T>
Bar<T> operator+(const T& L, Bar<T> const & R) { // Added
    return Bar<T>(L) + R;
}
于 2012-07-17T20:28:55.320 回答
1

int和之间没有隐式转换Bar，只有int和之间Bar<int>。实际上，您还没有定义类型Bar；相反，Bar<T>对于T. 可能您会看到与 的定义相关的编译器错误operator+，尽管它可能隐藏在一大堆其他模板类型错误的后面。

我面前没有 c++ 编译器，但我相信它的template<class T> Bar<T> operator+(Bar<T> const & L, Bar<T> const & R)行为会如您所愿。

于 2012-07-17T20:27:11.163 回答