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

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>呢？最后，当 StringNum(num) + value首先是StringNum时， num如何解决问题？

在这种情况下，如何正确实现 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

如在您的模板中，

您使用 operator+和 const StringNum&调用 StringNum
候选人是:

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)匹配，因此导致无限递归。