Question

我正在学习运算符重载，我找到了这个例子：

#include <iostream>
using namespace std;

class MinMax
{
private:
    int m_nMin; // The min value seen so far
    int m_nMax; // The max value seen so far

public:
    MinMax(int nMin, int nMax)
    {
        m_nMin = nMin;
        m_nMax = nMax;
    }

    int GetMin() { return m_nMin; }
    int GetMax() { return m_nMax; }

    friend MinMax operator+(const MinMax &cM1, const MinMax &cM2);
    friend MinMax operator+(const MinMax &cM, int nValue);
    friend MinMax operator+(int nValue, const MinMax &cM);
};

MinMax operator+(const MinMax &cM1, const MinMax &cM2)
{
    // Get the minimum value seen in cM1 and cM2
    int nMin = cM1.m_nMin < cM2.m_nMin ? cM1.m_nMin : cM2.m_nMin;

    // Get the maximum value seen in cM1 and cM2
    int nMax = cM1.m_nMax > cM2.m_nMax ? cM1.m_nMax : cM2.m_nMax;

    return MinMax(nMin, nMax);
}

MinMax operator+(const MinMax &cM, int nValue)
{
    // Get the minimum value seen in cM and nValue
    int nMin = cM.m_nMin < nValue ? cM.m_nMin : nValue;

    // Get the maximum value seen in cM and nValue
    int nMax = cM.m_nMax > nValue ? cM.m_nMax : nValue;

    return MinMax(nMin, nMax);
}

MinMax operator+(int nValue, const MinMax &cM)
{
    // call operator+(MinMax, nValue)
    return (cM + nValue);
}

int main()
{
    MinMax cM1(10, 15);
    MinMax cM2(8, 11);
    MinMax cM3(3, 12);

    MinMax cMFinal = cM1 + cM2 + 5 + 8 + cM3 + 16;

    cout << "Result: (" << cMFinal.GetMin() << ", " <<
        cMFinal.GetMax() << ")" << endl;

    return 0;
}

我不明白第MinMax cMFinal = cM1 + cM2 + 5 + 8 + cM3 + 16;行是如何工作的。

计算后，它变为MinMax cMFinal = MinMax(3, 16)。接下来会发生什么？当我没有定义重载分配运算符时，编译器如何将一个对象分配给另一个对象？

Answer 1

假设您有两个MinMax个对象，a和b。然后当你有像

这样的行

MinMax c = a + b;

然后编译器将其转换为以下

MinMax c = operator+(a, b);

换句话说，它就像正常的函数调用一样。

如果您执行多项操作，例如

MinMax d = a + b + c;

然后编译器将在内部生成临时变量并使用，如

MinMax compilerGeneratedTemporary = operator+(a, b);

MinMax d = operator+(compilerGeneratedTemporary, c);

如果它是您想知道的初始化，那么它会调用MinMax 复制构造函数。当您同时声明和初始化一个对象变量时，它不是一个赋值，它只是重用赋值运算符。

operator+函数返回一个MinMax对象，该对象将传递给类复制构造函数。

如果某个类没有复制构造函数，编译器会自动为您生成一个（除少数例外情况，请参阅下面链接的参考资料）。

Read more about the copy-constructor here

运算符重载示例不清楚

1 个答案: