交换运算符 + 重载会导致无限递归

Commutative operator + overloading causes infinite recursion

本文关键字：无限 递归 运算符 重载 交换      更新时间：2023-10-16
#include <iostream>
using namespace std;
class StringNum {
public:
string s;
StringNum() {s = "";}
public:
StringNum(int n) {
s = "";
for (int i=1; i<=n; i++) s += "x";
}
operator int () {
return s.length();
}
StringNum operator + (StringNum v) {
cout << "operator + is calledn";
int len = s.length() + v.s.length();
StringNum res;
for (int i=1;i<=len;i++) res.s += "x";
return res;
}
template <class T>
StringNum operator + (T value) {
return (*this) + StringNum(value);
}
};
template<class T>
StringNum operator + (T value, const StringNum& num) {
cout << "operator + opposite is calledn";
//return value + num; // infinite recursion, of course
// return num + value;  // infinite recursion, despite StringNum + <class T> is defined
return num + StringNum(value); // STILL infinite recursion
//return StringNum(num) + value; // correct, output 6
}
int main()
{
StringNum x(4);
cout << (x + 2.5) << "n"; // StringNum + <class T>, output 6
int res = (2 + x);
cout << res;
return 0;
}

类 StringNum 表示一个整数> 0，其中字符串的长度是数字。

StringNum + StringNum是成员函数，可以正常工作。

StringNum + <class T>也是一个成员函数，可以正常工作。

但是，对于<class T> + StringNum，它需要一个外部函数。但是，operator +的行为令人困惑，没有任何意义：

template<class T>
StringNum operator + (T value, const StringNum& num) {
cout << "operator + opposite is calledn";
//return value + num; // infinite recursion, of course
// return num + value;  // StringNum + <class T>, infinite recursion. Why??
return num + StringNum(value); // STILL infinite recursion
//return StringNum(num) + value; // StringNum + <class T> -> this time it's correct, output 6
}

为什么num + StringNum(value)会导致无限递归，而它应该调用StringNum + StringNum？另外，为什么num + value会导致无限递归，而它应该调用StringNum + <class T>？最后，当num首先是 StringNum 时，StringNum(num) + value如何解决问题？

在这种情况下，我如何正确实现commutative operator +？谢谢。

使用正确的恒常性：

StringNum operator + (const StringNum& v) const {
cout << "operator + is calledn";
int len = s.length() + v.s.length();
StringNum res;
for (int i=1;i<=len;i++) res.s += "x";
return res;
}
template <class T>
StringNum operator + (T value) const {
return (*this) + StringNum(value);
}

演示

就像在您的模板中一样，

你用const StringNum&和StringNum来称呼operator+

候选人是：

  • StringNum StringNum::operator + (StringNum v)不匹配，仅适用于非常量 lhs
  • template <class T> StringNum StringNum::operator + (T value)不匹配，原因与上述相同
  • template<class T> StringNum operator + (T value, const StringNum& num)匹配，因此导致无限递归。
相关文章：