Question

class binaryOperators 
{
    public:
        int i;

        binaryOperators (int tempI = 0)
        {
            i = tempI;
        }

        binaryOperators operator+ (const binaryOperators &right);
};

binaryOperators binaryOperators :: operator+ (const binaryOperators &right)
{
    return binaryOperators (*this + right.i);
}

binaryOperators operator+ (const binaryOperators &left, const binaryOperators &right)
{
    return binaryOperators (left.i + right.i);
}

int main ()
{
    binaryOperators obj (10);

    obj = 11 + obj;

    obj = obj + 11;

    return 0;
}

所以，这里语句obj = 11 + obj;使用显式参数规范调用该函数。这一个obj = obj + 11;调用函数，该函数是类的成员。精细。

问题是第二次调用导致无限循环。是什么原因以及如何避免这种情况？

Answer 1

问题出在声明中：

return binaryOperators (*this + right.i);

*this的类型为binaryOperators，因此需要一个运算符，其左侧参数类型（或引用）binaryOperators。

可能匹配的运算符是您提供的两个运算符，因此右侧参数必须是const binaryOperators &类型。因此，使用适当的构造函数将right.i转换为临时binaryOperators。

结果，成员操作符最终调用自身，调用自身，调用自身等，导致无限递归（你看作无限循环）。

您可以使用以下方法解决此问题：

return binaryOperators (this->i + right.i);

Answer 2

从binaryOperators::i（类型int）到binaryOperators的转换是隐式的（即未声明为explicit）。

return binaryOperators (*this + right.i); // (1)
binaryOperators binaryOperators :: operator+ (const binaryOperators &right); // (2)
binaryOperators operator+ (const binaryOperators &left, const binaryOperators &right); // (3)

在第（1）行中，可以考虑两个operator+函数：成员版本（2）和免费版本（3）。由于LHS属于binaryOperators&类型，因此成员版本适用且首选。它的参数类型为const binaryOperators &，而行（1）中给出的参数的类型为int，因此编译器会尝试将int转换为const binaryOperators &。

由于存在一个带有一个参数的非explicit构造函数，因此它被用作从int到const binaryOperators &的隐式转换。现在我们有两个类型binaryOperators&和const binaryOperators &的操作数，可以调用（2）中的operator+，我们就在我们开始的地方。

课程：不要过度隐式转换。

为什么返回*会导致无限循环？

2 个答案: