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

Question

#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 called\n";
        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 called\n";
    //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 called\n";
    //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 +？谢谢。

Answer 1

使用正确的常量：

StringNum operator + (const StringNum& v) const {
    cout << "operator + is called\n";
    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);
}

Demo

在您的模板中，

你用const StringNum&和StringNum打电话给operator+

候选人是：

• StringNum StringNum::operator + (StringNum v) 不匹配，仅适用于非 const lhs
• template <class T> StringNum StringNum::operator + (T value) 不匹配，同上原因
• template<class T> StringNum operator + (T value, const StringNum& num) 匹配，所以导致无限递归。